Gtk324 = Gtk324 or {}
Gtk324.__version_no__ = "Gtk324"
Gtk324.__module_name__ = "gtk+-3.0"

----  [Gtk interfaces] Start ... 
---------------------  GtkActionable
Gtk324.GtkActionable = {
  class = "GtkActionable", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    get_action_name         = {"const gchar*", {"GtkActionable*"}, {"actionable"} }, 
    get_action_target_value = {"GVariant*"   , {"GtkActionable*"}, {"actionable"} }, 
    set_action_name         = {"void"        , {"GtkActionable*", "const gchar*"}, {"actionable", "action_name"} }, 
    set_action_target_value = {"void"        , {"GtkActionable*", "GVariant*"}, {"actionable", "target_value"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["action-name"]   = {__type__="gchar*"    ,__default__ = "NULL" , __gencode__ = {"gtk_actionable_set_action_name((GtkActionable*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["action-target"] = {__type__="GVariant*" ,__default__ = "NULL" , __gencode__ = {"gtk_actionable_set_action_target((GtkActionable*)({* id *}), (const gchar*)({* property.value *}), (void)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkActivatable
Gtk324.GtkActivatable = {
  class = "GtkActivatable", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    sync_action_properties = {"void", {"GtkActivatable*", "GtkAction*"}, {"activatable", "action"} }, 
    update                 = {"void", {"GtkActivatable*", "GtkAction*", "const gchar*"}, {"activatable", "action", "property_name"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["related-action"]        = {__type__="GtkAction*"                       , __gencode__ = {"gtk_activatable_set_related_action((GtkActivatable*)({* id *}), (GtkAction*)({* property.value *}))"} },
    ["use-action-appearance"] = {__type__="gboolean"   ,__default__ = "TRUE" , __gencode__ = {"gtk_activatable_set_use_action_appearance((GtkActivatable*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkAppChooser
Gtk324.GtkAppChooser = {
  class = "GtkAppChooser", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["content-type"] = {__type__="gchar*" ,__default__ = "NULL" ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkBuildable
Gtk324.GtkBuildable = {
  class = "GtkBuildable", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    add_child              = {"void"        , {"GtkBuildable*", "GtkBuilder*", "GObject*", "const gchar*"}, {"buildable", "builder", "child", "type"} }, 
    construct_child        = {"GObject*"    , {"GtkBuildable*", "GtkBuilder*", "const gchar*"}, {"buildable", "builder", "name"} }, 
    custom_finished        = {"void"        , {"GtkBuildable*", "GtkBuilder*", "GObject*", "const gchar*", "gpointer"}, {"buildable", "builder", "child", "tagname", "data"} }, 
    custom_tag_end         = {"void"        , {"GtkBuildable*", "GtkBuilder*", "GObject*", "const gchar*", "gpointer*"}, {"buildable", "builder", "child", "tagname", "data"} }, 
    custom_tag_start       = {"gboolean"    , {"GtkBuildable*", "GtkBuilder*", "GObject*", "const gchar*", "GMarkupParser*", "gpointer*"}, {"buildable", "builder", "child", "tagname", "parser", "data"} }, 
    get_internal_child     = {"GObject*"    , {"GtkBuildable*", "GtkBuilder*", "const gchar*"}, {"buildable", "builder", "childname"} }, 
    get_name               = {"const gchar*", {"GtkBuildable*"}, {"buildable"} }, 
    parser_finished        = {"void"        , {"GtkBuildable*", "GtkBuilder*"}, {"buildable", "builder"} }, 
    set_buildable_property = {"void"        , {"GtkBuildable*", "GtkBuilder*", "const gchar*", "const GValue*"}, {"buildable", "builder", "name", "value"} }, 
    set_name               = {"void"        , {"GtkBuildable*", "const gchar*"}, {"buildable", "name"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkCellAccessibleParent
Gtk324.GtkCellAccessibleParent = {
  class = "GtkCellAccessibleParent", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate                = {"void"                , {"GtkCellAccessibleParent*", "GtkCellAccessible*"}, {"parent", "cell"} }, 
    edit                    = {"void"                , {"GtkCellAccessibleParent*", "GtkCellAccessible*"}, {"parent", "cell"} }, 
    expand_collapse         = {"void"                , {"GtkCellAccessibleParent*", "GtkCellAccessible*"}, {"parent", "cell"} }, 
    get_cell_area           = {"void"                , {"GtkCellAccessibleParent*", "GtkCellAccessible*", "GdkRectangle*"}, {"parent", "cell", "cell_rect"} }, 
    get_cell_extents        = {"void"                , {"GtkCellAccessibleParent*", "GtkCellAccessible*", "gint*", "gint*", "gint*", "gint*", "AtkCoordType"}, {"parent", "cell", "x", "y", "width", "height", "coord_type"} }, 
    get_cell_position       = {"void"                , {"GtkCellAccessibleParent*", "GtkCellAccessible*", "gint*", "gint*"}, {"parent", "cell", "row", "column"} }, 
    get_child_index         = {"int"                 , {"GtkCellAccessibleParent*", "GtkCellAccessible*"}, {"parent", "cell"} }, 
    get_column_header_cells = {"GPtrArray*"          , {"GtkCellAccessibleParent*", "GtkCellAccessible*"}, {"parent", "cell"} }, 
    get_renderer_state      = {"GtkCellRendererState", {"GtkCellAccessibleParent*", "GtkCellAccessible*"}, {"parent", "cell"} }, 
    get_row_header_cells    = {"GPtrArray*"          , {"GtkCellAccessibleParent*", "GtkCellAccessible*"}, {"parent", "cell"} }, 
    grab_focus              = {"gboolean"            , {"GtkCellAccessibleParent*", "GtkCellAccessible*"}, {"parent", "cell"} }, 
    update_relationset      = {"void"                , {"GtkCellAccessibleParent*", "GtkCellAccessible*", "AtkRelationSet*"}, {"parent", "cell", "relationset"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkCellEditable
Gtk324.GtkCellEditable = {
  class = "GtkCellEditable", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    editing_done  = {"void", {"GtkCellEditable*"}, {"cell_editable"} }, 
    remove_widget = {"void", {"GtkCellEditable*"}, {"cell_editable"} }, 
    start_editing = {"void", {"GtkCellEditable*", "GdkEvent*"}, {"cell_editable", "event"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['editing-done']  = {ret_type = "void", params = {type = {"GtkCellEditable*"}, name ={"celleditable"}} }, 
    ['remove-widget'] = {ret_type = "void", params = {type = {"GtkCellEditable*"}, name ={"celleditable"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["editing-canceled"] = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkCellLayout
Gtk324.GtkCellLayout = {
  class = "GtkCellLayout", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    add_attribute      = {"void"        , {"GtkCellLayout*", "GtkCellRenderer*", "const gchar*", "gint"}, {"cell_layout", "cell", "attribute", "column"} }, 
    clear              = {"void"        , {"GtkCellLayout*"}, {"cell_layout"} }, 
    clear_attributes   = {"void"        , {"GtkCellLayout*", "GtkCellRenderer*"}, {"cell_layout", "cell"} }, 
    get_area           = {"GtkCellArea*", {"GtkCellLayout*"}, {"cell_layout"} }, 
    get_cells          = {"GList*"      , {"GtkCellLayout*"}, {"cell_layout"} }, 
    pack_end           = {"void"        , {"GtkCellLayout*", "GtkCellRenderer*", "gboolean"}, {"cell_layout", "cell", "expand"} }, 
    pack_start         = {"void"        , {"GtkCellLayout*", "GtkCellRenderer*", "gboolean"}, {"cell_layout", "cell", "expand"} }, 
    reorder            = {"void"        , {"GtkCellLayout*", "GtkCellRenderer*", "gint"}, {"cell_layout", "cell", "position"} }, 
    set_cell_data_func = {"void"        , {"GtkCellLayout*", "GtkCellRenderer*", "GtkCellLayoutDataFunc", "gpointer", "GDestroyNotify"}, {"cell_layout", "cell", "func", "func_data", "destroy"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkColorChooser
Gtk324.GtkColorChooser = {
  class = "GtkColorChooser", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    add_palette     = {"void", {"GtkColorChooser*", "GtkOrientation", "gint", "gint", "GdkRGBA*"}, {"chooser", "orientation", "colors_per_line", "n_colors", "colors"} }, 
    color_activated = {"void", {"GtkColorChooser*", "const GdkRGBA*"}, {"chooser", "color"} }, 
    get_rgba        = {"void", {"GtkColorChooser*", "GdkRGBA*"}, {"chooser", "color"} }, 
    set_rgba        = {"void", {"GtkColorChooser*", "const GdkRGBA*"}, {"chooser", "color"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['color-activated'] = {ret_type = "void", params = {type = {"GtkColorChooser*", "GdkRGBA*"}, name ={"colorchooser", "color"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    rgba          = {__type__="GdkRGBA*"                       , __gencode__ = {"gtk_color_chooser_set_rgba((GtkColorChooser*)({* id *}), (const GdkRGBA*)({* property.value *}))"} },
    ["use-alpha"] = {__type__="gboolean" ,__default__ = "TRUE" , __gencode__ = {"gtk_color_chooser_set_use_alpha((GtkColorChooser*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkEditable
Gtk324.GtkEditable = {
  class = "GtkEditable", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    changed              = {"void"    , {"GtkEditable*"}, {"editable"} }, 
    delete_text          = {"void"    , {"GtkEditable*", "gint", "gint"}, {"editable", "start_pos", "end_pos"} }, 
    do_delete_text       = {"void"    , {"GtkEditable*", "gint", "gint"}, {"editable", "start_pos", "end_pos"} }, 
    do_insert_text       = {"void"    , {"GtkEditable*", "const gchar*", "gint", "gint*"}, {"editable", "new_text", "new_text_length", "position"} }, 
    get_chars            = {"gchar*"  , {"GtkEditable*", "gint", "gint"}, {"editable", "start_pos", "end_pos"} }, 
    get_position         = {"gint"    , {"GtkEditable*"}, {"editable"} }, 
    get_selection_bounds = {"gboolean", {"GtkEditable*", "gint*", "gint*"}, {"editable", "start_pos", "end_pos"} }, 
    insert_text          = {"void"    , {"GtkEditable*", "const gchar*", "gint", "gint*"}, {"editable", "new_text", "new_text_length", "position"} }, 
    set_position         = {"void"    , {"GtkEditable*", "gint"}, {"editable", "position"} }, 
    set_selection_bounds = {"void"    , {"GtkEditable*", "gint", "gint"}, {"editable", "start_pos", "end_pos"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed         = {ret_type = "void", params = {type = {"GtkEditable*"}, name ={"editable"}} }, 
    ['delete-text'] = {ret_type = "void", params = {type = {"GtkEditable*", "gint", "gint"}, name ={"editable", "start_pos", "end_pos"}} }, 
    ['insert-text'] = {ret_type = "void", params = {type = {"GtkEditable*", "gchar*", "gint", "gpointer"}, name ={"editable", "new_text", "new_text_length", "position"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkFileChooser
Gtk324.GtkFileChooser = {
  class = "GtkFileChooser", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['confirm-overwrite']      = {ret_type = "{FileChooserConfirmation}", params = {type = {"GtkFileChooser*"}, name ={"filechooser"}} }, 
    ['current-folder-changed'] = {ret_type = "void"                     , params = {type = {"GtkFileChooser*"}, name ={"filechooser"}} }, 
    ['file-activated']         = {ret_type = "void"                     , params = {type = {"GtkFileChooser*"}, name ={"filechooser"}} }, 
    ['selection-changed']      = {ret_type = "void"                     , params = {type = {"GtkFileChooser*"}, name ={"filechooser"}} }, 
    ['update-preview']         = {ret_type = "void"                     , params = {type = {"GtkFileChooser*"}, name ={"filechooser"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    action                        = {__type__="GtkFileChooserAction" ,__default__ = "GTK_FILE_CHOOSER_ACTION_OPEN" , __gencode__ = {"gtk_file_chooser_set_action((GtkFileChooser*)({* id *}), (GtkFileChooserAction)({* property.value *}))"} },
    ["create-folders"]            = {__type__="gboolean"             ,__default__ = "TRUE"                         , __gencode__ = {"gtk_file_chooser_set_create_folders((GtkFileChooser*)({* id *}), (gboolean)({* property.value *}))"} },
    ["do-overwrite-confirmation"] = {__type__="gboolean"             ,__default__ = "FALSE"                        , __gencode__ = {"gtk_file_chooser_set_do_overwrite_confirmation((GtkFileChooser*)({* id *}), (gboolean)({* property.value *}))"} },
    ["extra-widget"]              = {__type__="GtkWidget*"                                                         , __gencode__ = {"gtk_file_chooser_set_extra_widget((GtkFileChooser*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    filter                        = {__type__="GtkFileFilter*"                                                     , __gencode__ = {"gtk_file_chooser_set_filter((GtkFileChooser*)({* id *}), (GtkFileFilter*)({* property.value *}))"} },
    ["local-only"]                = {__type__="gboolean"             ,__default__ = "TRUE"                         , __gencode__ = {"gtk_file_chooser_set_local_only((GtkFileChooser*)({* id *}), (gboolean)({* property.value *}))"} },
    ["preview-widget"]            = {__type__="GtkWidget*"                                                         , __gencode__ = {"gtk_file_chooser_set_preview_widget((GtkFileChooser*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["preview-widget-active"]     = {__type__="gboolean"             ,__default__ = "TRUE"                         , __gencode__ = {"gtk_file_chooser_set_preview_widget_active((GtkFileChooser*)({* id *}), (gboolean)({* property.value *}))"} },
    ["select-multiple"]           = {__type__="gboolean"             ,__default__ = "FALSE"                        , __gencode__ = {"gtk_file_chooser_set_select_multiple((GtkFileChooser*)({* id *}), (gboolean)({* property.value *}))"} },
    ["show-hidden"]               = {__type__="gboolean"             ,__default__ = "FALSE"                        , __gencode__ = {"gtk_file_chooser_set_show_hidden((GtkFileChooser*)({* id *}), (gboolean)({* property.value *}))"} },
    ["use-preview-label"]         = {__type__="gboolean"             ,__default__ = "TRUE"                         , __gencode__ = {"gtk_file_chooser_set_use_preview_label((GtkFileChooser*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkFontChooser
Gtk324.GtkFontChooser = {
  class = "GtkFontChooser", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    font_activated  = {"void"            , {"GtkFontChooser*", "const gchar*"}, {"chooser", "fontname"} }, 
    get_font_face   = {"PangoFontFace*"  , {"GtkFontChooser*"}, {"fontchooser"} }, 
    get_font_family = {"PangoFontFamily*", {"GtkFontChooser*"}, {"fontchooser"} }, 
    get_font_map    = {"PangoFontMap*"   , {"GtkFontChooser*"}, {"fontchooser"} }, 
    get_font_size   = {"gint"            , {"GtkFontChooser*"}, {"fontchooser"} }, 
    set_filter_func = {"void"            , {"GtkFontChooser*", "GtkFontFilterFunc", "gpointer", "GDestroyNotify"}, {"fontchooser", "filter", "user_data", "destroy"} }, 
    set_font_map    = {"void"            , {"GtkFontChooser*", "PangoFontMap*"}, {"fontchooser", "fontmap"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['font-activated'] = {ret_type = "void", params = {type = {"GtkFontChooser*", "gchar*"}, name ={"fontchooser", "fontname"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    font                   = {__type__="gchar*"                ,__default__ = "\"Sans 10\""                                                , __gencode__ = {"gtk_font_chooser_set_font((GtkFontChooser*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["font-desc"]          = {__type__="PangoFontDescription*"                                                                             , __gencode__ = {"gtk_font_chooser_set_font_desc((GtkFontChooser*)({* id *}), (const PangoFontDescription*)({* property.value *}))"} },
    ["font-features"]      = {__type__="gchar*"                ,__default__ = "\"\""                                                        },
    language               = {__type__="gchar*"                ,__default__ = "\"\""                                                       , __gencode__ = {"gtk_font_chooser_set_language((GtkFontChooser*)({* id *}), (const char*)({* property.value *}))"} },
    level                  = {__type__="GtkFontChooserLevel"   ,__default__ = "GTK_FONT_CHOOSER_LEVEL_STYLE | GTK_FONT_CHOOSER_LEVEL_SIZE" , __gencode__ = {"gtk_font_chooser_set_level((GtkFontChooser*)({* id *}), (GtkFontChooserLevel)({* property.value *}))"} },
    ["preview-text"]       = {__type__="gchar*"                ,__default__ = "\"The quick brown fox jumps over the lazy dog.\""           , __gencode__ = {"gtk_font_chooser_set_preview_text((GtkFontChooser*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["show-preview-entry"] = {__type__="gboolean"              ,__default__ = "TRUE"                                                       , __gencode__ = {"gtk_font_chooser_set_show_preview_entry((GtkFontChooser*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkOrientable
Gtk324.GtkOrientable = {
  class = "GtkOrientable", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    orientation = {__type__="GtkOrientation" ,__default__ = "GTK_ORIENTATION_HORIZONTAL" , __gencode__ = {"gtk_orientable_set_orientation((GtkOrientable*)({* id *}), (GtkOrientation)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkPrintOperationPreview
Gtk324.GtkPrintOperationPreview = {
  class = "GtkPrintOperationPreview", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    end_preview   = {"void"    , {"GtkPrintOperationPreview*"}, {"preview"} }, 
    got_page_size = {"void"    , {"GtkPrintOperationPreview*", "GtkPrintContext*", "GtkPageSetup*"}, {"preview", "context", "page_setup"} }, 
    is_selected   = {"gboolean", {"GtkPrintOperationPreview*", "gint"}, {"preview", "page_nr"} }, 
    ready         = {"void"    , {"GtkPrintOperationPreview*", "GtkPrintContext*"}, {"preview", "context"} }, 
    render_page   = {"void"    , {"GtkPrintOperationPreview*", "gint"}, {"preview", "page_nr"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['got-page-size'] = {ret_type = "void", params = {type = {"GtkPrintOperationPreview*", "GtkPrintContext*", "GtkPageSetup*"}, name ={"printoperationpreview", "context", "page_setup"}} }, 
    ready             = {ret_type = "void", params = {type = {"GtkPrintOperationPreview*", "GtkPrintContext*"}, name ={"preview", "context"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkRecentChooser
Gtk324.GtkRecentChooser = {
  class = "GtkRecentChooser", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    add_filter         = {"void"             , {"GtkRecentChooser*", "GtkRecentFilter*"}, {"chooser", "filter"} }, 
    get_current_uri    = {"gchar*"           , {"GtkRecentChooser*"}, {"chooser"} }, 
    get_items          = {"GList*"           , {"GtkRecentChooser*"}, {"chooser"} }, 
    get_recent_manager = {"GtkRecentManager*", {"GtkRecentChooser*"}, {"chooser"} }, 
    item_activated     = {"void"             , {"GtkRecentChooser*"}, {"chooser"} }, 
    list_filters       = {"GSList*"          , {"GtkRecentChooser*"}, {"chooser"} }, 
    remove_filter      = {"void"             , {"GtkRecentChooser*", "GtkRecentFilter*"}, {"chooser", "filter"} }, 
    select_all         = {"void"             , {"GtkRecentChooser*"}, {"chooser"} }, 
    select_uri         = {"gboolean"         , {"GtkRecentChooser*", "const gchar*"}, {"chooser", "uri"} }, 
    selection_changed  = {"void"             , {"GtkRecentChooser*"}, {"chooser"} }, 
    set_current_uri    = {"gboolean"         , {"GtkRecentChooser*", "const gchar*"}, {"chooser", "uri"} }, 
    set_sort_func      = {"void"             , {"GtkRecentChooser*", "GtkRecentSortFunc", "gpointer", "GDestroyNotify"}, {"chooser", "sort_func", "sort_data", "data_destroy"} }, 
    unselect_all       = {"void"             , {"GtkRecentChooser*"}, {"chooser"} }, 
    unselect_uri       = {"void"             , {"GtkRecentChooser*", "const gchar*"}, {"chooser", "uri"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['item-activated']    = {ret_type = "void", params = {type = {"GtkRecentChooser*"}, name ={"recentchooser"}} }, 
    ['selection-changed'] = {ret_type = "void", params = {type = {"GtkRecentChooser*"}, name ={"recentchooser"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    filter              = {__type__="GtkRecentFilter*"                                        , __gencode__ = {"gtk_recent_chooser_set_filter((GtkRecentChooser*)({* id *}), (GtkRecentFilter*)({* property.value *}))"} },
    limit               = {__type__="gint"              ,__default__ = "50"                   , __gencode__ = {"gtk_recent_chooser_set_limit((GtkRecentChooser*)({* id *}), (gint)({* property.value *}))"} },
    ["local-only"]      = {__type__="gboolean"          ,__default__ = "TRUE"                 , __gencode__ = {"gtk_recent_chooser_set_local_only((GtkRecentChooser*)({* id *}), (gboolean)({* property.value *}))"} },
    ["recent-manager"]  = {__type__="GtkRecentManager*"                                       ,rwflags="w" },
    ["select-multiple"] = {__type__="gboolean"          ,__default__ = "FALSE"                , __gencode__ = {"gtk_recent_chooser_set_select_multiple((GtkRecentChooser*)({* id *}), (gboolean)({* property.value *}))"} },
    ["show-icons"]      = {__type__="gboolean"          ,__default__ = "TRUE"                 , __gencode__ = {"gtk_recent_chooser_set_show_icons((GtkRecentChooser*)({* id *}), (gboolean)({* property.value *}))"} },
    ["show-not-found"]  = {__type__="gboolean"          ,__default__ = "TRUE"                 , __gencode__ = {"gtk_recent_chooser_set_show_not_found((GtkRecentChooser*)({* id *}), (gboolean)({* property.value *}))"} },
    ["show-private"]    = {__type__="gboolean"          ,__default__ = "FALSE"                , __gencode__ = {"gtk_recent_chooser_set_show_private((GtkRecentChooser*)({* id *}), (gboolean)({* property.value *}))"} },
    ["show-tips"]       = {__type__="gboolean"          ,__default__ = "FALSE"                , __gencode__ = {"gtk_recent_chooser_set_show_tips((GtkRecentChooser*)({* id *}), (gboolean)({* property.value *}))"} },
    ["sort-type"]       = {__type__="GtkRecentSortType" ,__default__ = "GTK_RECENT_SORT_NONE" , __gencode__ = {"gtk_recent_chooser_set_sort_type((GtkRecentChooser*)({* id *}), (GtkRecentSortType)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkScrollable
Gtk324.GtkScrollable = {
  class = "GtkScrollable", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    get_border = {"gboolean", {"GtkScrollable*", "GtkBorder*"}, {"scrollable", "border"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    hadjustment        = {__type__="GtkAdjustment*"                                          , __gencode__ = {"gtk_scrollable_set_hadjustment((GtkScrollable*)({* id *}), (GtkAdjustment*)({* property.value *}))"},__construct__= 1 },
    ["hscroll-policy"] = {__type__="GtkScrollablePolicy" ,__default__ = "GTK_SCROLL_MINIMUM" , __gencode__ = {"gtk_scrollable_set_hscroll_policy((GtkScrollable*)({* id *}), (GtkScrollablePolicy)({* property.value *}))"} },
    vadjustment        = {__type__="GtkAdjustment*"                                          , __gencode__ = {"gtk_scrollable_set_vadjustment((GtkScrollable*)({* id *}), (GtkAdjustment*)({* property.value *}))"},__construct__= 1 },
    ["vscroll-policy"] = {__type__="GtkScrollablePolicy" ,__default__ = "GTK_SCROLL_MINIMUM" , __gencode__ = {"gtk_scrollable_set_vscroll_policy((GtkScrollable*)({* id *}), (GtkScrollablePolicy)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkStyleProvider
Gtk324.GtkStyleProvider = {
  class = "GtkStyleProvider", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    get_icon_factory   = {"GtkIconFactory*"    , {"GtkStyleProvider*", "GtkWidgetPath*"}, {"provider", "path"} }, 
    get_style          = {"GtkStyleProperties*", {"GtkStyleProvider*", "GtkWidgetPath*"}, {"provider", "path"} }, 
    get_style_property = {"gboolean"           , {"GtkStyleProvider*", "GtkWidgetPath*", "GtkStateFlags", "GParamSpec*", "GValue*"}, {"provider", "path", "state", "pspec", "value"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkToolShell
Gtk324.GtkToolShell = {
  class = "GtkToolShell", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    get_ellipsize_mode   = {"PangoEllipsizeMode", {"GtkToolShell*"}, {"shell"} }, 
    get_icon_size        = {"GtkIconSize"       , {"GtkToolShell*"}, {"shell"} }, 
    get_orientation      = {"GtkOrientation"    , {"GtkToolShell*"}, {"shell"} }, 
    get_relief_style     = {"GtkReliefStyle"    , {"GtkToolShell*"}, {"shell"} }, 
    get_style            = {"GtkToolbarStyle"   , {"GtkToolShell*"}, {"shell"} }, 
    get_text_alignment   = {"gfloat"            , {"GtkToolShell*"}, {"shell"} }, 
    get_text_orientation = {"GtkOrientation"    , {"GtkToolShell*"}, {"shell"} }, 
    get_text_size_group  = {"GtkSizeGroup*"     , {"GtkToolShell*"}, {"shell"} }, 
    rebuild_menu         = {"void"              , {"GtkToolShell*"}, {"shell"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkTreeDragDest
Gtk324.GtkTreeDragDest = {
  class = "GtkTreeDragDest", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    drag_data_received = {"gboolean", {"GtkTreeDragDest*", "GtkTreePath*", "GtkSelectionData*"}, {"drag_dest", "dest", "selection_data"} }, 
    row_drop_possible  = {"gboolean", {"GtkTreeDragDest*", "GtkTreePath*", "GtkSelectionData*"}, {"drag_dest", "dest_path", "selection_data"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkTreeDragSource
Gtk324.GtkTreeDragSource = {
  class = "GtkTreeDragSource", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    drag_data_delete = {"gboolean", {"GtkTreeDragSource*", "GtkTreePath*"}, {"drag_source", "path"} }, 
    drag_data_get    = {"gboolean", {"GtkTreeDragSource*", "GtkTreePath*", "GtkSelectionData*"}, {"drag_source", "path", "selection_data"} }, 
    row_draggable    = {"gboolean", {"GtkTreeDragSource*", "GtkTreePath*"}, {"drag_source", "path"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkTreeModel
Gtk324.GtkTreeModel = {
  class = "GtkTreeModel", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    get_column_type       = {"GType"            , {"GtkTreeModel*", "gint"}, {"tree_model", "index_"} }, 
    get_flags             = {"GtkTreeModelFlags", {"GtkTreeModel*"}, {"tree_model"} }, 
    get_iter              = {"gboolean"         , {"GtkTreeModel*", "GtkTreeIter*", "GtkTreePath*"}, {"tree_model", "iter", "path"} }, 
    get_n_columns         = {"gint"             , {"GtkTreeModel*"}, {"tree_model"} }, 
    get_path              = {"GtkTreePath*"     , {"GtkTreeModel*", "GtkTreeIter*"}, {"tree_model", "iter"} }, 
    get_value             = {"void"             , {"GtkTreeModel*", "GtkTreeIter*", "gint", "GValue*"}, {"tree_model", "iter", "column", "value"} }, 
    iter_children         = {"gboolean"         , {"GtkTreeModel*", "GtkTreeIter*", "GtkTreeIter*"}, {"tree_model", "iter", "parent"} }, 
    iter_has_child        = {"gboolean"         , {"GtkTreeModel*", "GtkTreeIter*"}, {"tree_model", "iter"} }, 
    iter_n_children       = {"gint"             , {"GtkTreeModel*", "GtkTreeIter*"}, {"tree_model", "iter"} }, 
    iter_next             = {"gboolean"         , {"GtkTreeModel*", "GtkTreeIter*"}, {"tree_model", "iter"} }, 
    iter_nth_child        = {"gboolean"         , {"GtkTreeModel*", "GtkTreeIter*", "GtkTreeIter*", "gint"}, {"tree_model", "iter", "parent", "n"} }, 
    iter_parent           = {"gboolean"         , {"GtkTreeModel*", "GtkTreeIter*", "GtkTreeIter*"}, {"tree_model", "iter", "child"} }, 
    iter_previous         = {"gboolean"         , {"GtkTreeModel*", "GtkTreeIter*"}, {"tree_model", "iter"} }, 
    ref_node              = {"void"             , {"GtkTreeModel*", "GtkTreeIter*"}, {"tree_model", "iter"} }, 
    row_changed           = {"void"             , {"GtkTreeModel*", "GtkTreePath*", "GtkTreeIter*"}, {"tree_model", "path", "iter"} }, 
    row_deleted           = {"void"             , {"GtkTreeModel*", "GtkTreePath*"}, {"tree_model", "path"} }, 
    row_has_child_toggled = {"void"             , {"GtkTreeModel*", "GtkTreePath*", "GtkTreeIter*"}, {"tree_model", "path", "iter"} }, 
    row_inserted          = {"void"             , {"GtkTreeModel*", "GtkTreePath*", "GtkTreeIter*"}, {"tree_model", "path", "iter"} }, 
    rows_reordered        = {"void"             , {"GtkTreeModel*", "GtkTreePath*", "GtkTreeIter*", "gint*"}, {"tree_model", "path", "iter", "new_order"} }, 
    unref_node            = {"void"             , {"GtkTreeModel*", "GtkTreeIter*"}, {"tree_model", "iter"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['row-changed']           = {ret_type = "void", params = {type = {"GtkTreeModel*", "GtkTreePath*", "GtkTreeIter*"}, name ={"treemodel", "path", "iter"}} }, 
    ['row-deleted']           = {ret_type = "void", params = {type = {"GtkTreeModel*", "GtkTreePath*"}, name ={"treemodel", "path"}} }, 
    ['row-has-child-toggled'] = {ret_type = "void", params = {type = {"GtkTreeModel*", "GtkTreePath*", "GtkTreeIter*"}, name ={"treemodel", "path", "iter"}} }, 
    ['row-inserted']          = {ret_type = "void", params = {type = {"GtkTreeModel*", "GtkTreePath*", "GtkTreeIter*"}, name ={"treemodel", "path", "iter"}} }, 
    ['rows-reordered']        = {ret_type = "void", params = {type = {"GtkTreeModel*", "GtkTreePath*", "GtkTreeIter*", "gpointer"}, name ={"treemodel", "path", "iter", "new_order"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkTreeSortable
Gtk324.GtkTreeSortable = {
  class = "GtkTreeSortable", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    get_sort_column_id    = {"gboolean", {"GtkTreeSortable*", "gint*", "GtkSortType*"}, {"sortable", "sort_column_id", "order"} }, 
    has_default_sort_func = {"gboolean", {"GtkTreeSortable*"}, {"sortable"} }, 
    set_default_sort_func = {"void"    , {"GtkTreeSortable*", "GtkTreeIterCompareFunc", "gpointer", "GDestroyNotify"}, {"sortable", "sort_func", "user_data", "destroy"} }, 
    set_sort_column_id    = {"void"    , {"GtkTreeSortable*", "gint", "GtkSortType"}, {"sortable", "sort_column_id", "order"} }, 
    set_sort_func         = {"void"    , {"GtkTreeSortable*", "gint", "GtkTreeIterCompareFunc", "gpointer", "GDestroyNotify"}, {"sortable", "sort_column_id", "sort_func", "user_data", "destroy"} }, 
    sort_column_changed   = {"void"    , {"GtkTreeSortable*"}, {"sortable"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['sort-column-changed'] = {ret_type = "void", params = {type = {"GtkTreeSortable*"}, name ={"treesortable"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

----  [Gtk interfaces] End ... 
----  [Gtk Classes] Start 
---------------------  GtkAccelGroup
Gtk324.GtkAccelGroup = {
  class = "GtkAccelGroup", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_accel_group_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    accel_changed = {"void", {"GtkAccelGroup*", "guint", "GdkModifierType", "GClosure*"}, {"accel_group", "keyval", "modifier", "accel_closure"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['accel-activate'] = {ret_type = "gboolean", params = {type = {"GtkAccelGroup*", "GObject*", "guint", "GdkModifierType*"}, name ={"accelgroup", "acceleratable", "keyval", "modifier"}} }, 
    ['accel-changed']  = {ret_type = "void"    , params = {type = {"GtkAccelGroup*", "guint", "GdkModifierType*", "GClosure*"}, name ={"accelgroup", "keyval", "modifier", "accel_closure"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["is-locked"]     = {__type__="gboolean"         ,__default__ = "FALSE"  },
    ["modifier-mask"] = {__type__="GdkModifierType*"                         },
  },
  parent = nil, 
};

---------------------  GtkAccelMap
Gtk324.GtkAccelMap = {
  class = "GtkAccelMap", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed = {ret_type = "void", params = {type = {"GtkAccelMap*", "gchar*", "guint", "GdkModifierType*"}, name ={"accelmap", "accel_path", "accel_key", "accel_mods"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkAccessible
Gtk324.GtkAccessible = {
  class = "GtkAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    connect_widget_destroyed = {"void", {"GtkAccessible*"}, {"accessible"} }, 
    widget_set               = {"void", {"GtkAccessible*"}, {"accessible"} }, 
    widget_unset             = {"void", {"GtkAccessible*"}, {"accessible"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    widget = {__type__="GtkWidget*" , __gencode__ = {"gtk_accessible_set_widget((GtkAccessible*)({* id *}), (GtkWidget*)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkAction
Gtk324.GtkAction = {
  class = "GtkAction", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_action_new((const gchar*)({* this.name.value *}), (const gchar*)({* this.label.value *}), (const gchar*)({* this.tooltip.value *}), (const gchar*)({* this['stock-id'].value *}))", 
            params = { type = {"const gchar*", "const gchar*", "const gchar*", "const gchar*"}, 
                       name = {"name", "label", "tooltip", "stock-id"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate         = {"void"      , {"GtkAction*"}, {"action"} }, 
    connect_proxy    = {"void"      , {"GtkAction*", "GtkWidget*"}, {"action", "proxy"} }, 
    create_menu      = {"GtkWidget*", {"GtkAction*"}, {"action"} }, 
    create_menu_item = {"GtkWidget*", {"GtkAction*"}, {"action"} }, 
    create_tool_item = {"GtkWidget*", {"GtkAction*"}, {"action"} }, 
    disconnect_proxy = {"void"      , {"GtkAction*", "GtkWidget*"}, {"action", "proxy"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate = {ret_type = "void", params = {type = {"GtkAction*"}, name ={"action"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["action-group"]       = {__type__="GtkActionGroup*"                        ,rwflags="rw" },
    ["always-show-image"]  = {__type__="gboolean"        ,__default__ = "FALSE" , __gencode__ = {"gtk_action_set_always_show_image((GtkAction*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    gicon                  = {__type__="GIcon*"                                 , __gencode__ = {"gtk_action_set_gicon((GtkAction*)({* id *}), (GIcon*)({* property.value *}))"} },
    ["hide-if-empty"]      = {__type__="gboolean"        ,__default__ = "TRUE"  ,rwflags="rw" },
    ["icon-name"]          = {__type__="gchar*"          ,__default__ = "NULL"  , __gencode__ = {"gtk_action_set_icon_name((GtkAction*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["is-important"]       = {__type__="gboolean"        ,__default__ = "FALSE" , __gencode__ = {"gtk_action_set_is_important((GtkAction*)({* id *}), (gboolean)({* property.value *}))"} },
    label                  = {__type__="gchar*"          ,__default__ = "NULL"  , __gencode__ = {"gtk_action_set_label((GtkAction*)({* id *}), (const gchar*)({* property.value *}))"} },
    name                   = {__type__="gchar*"          ,__default__ = "NULL"  ,rwflags="rw" },
    sensitive              = {__type__="gboolean"        ,__default__ = "TRUE"  , __gencode__ = {"gtk_action_set_sensitive((GtkAction*)({* id *}), (gboolean)({* property.value *}))"} },
    ["short-label"]        = {__type__="gchar*"          ,__default__ = "NULL"  , __gencode__ = {"gtk_action_set_short_label((GtkAction*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["stock-id"]           = {__type__="gchar*"          ,__default__ = "NULL"  , __gencode__ = {"gtk_action_set_stock_id((GtkAction*)({* id *}), (const gchar*)({* property.value *}))"} },
    tooltip                = {__type__="gchar*"          ,__default__ = "NULL"  , __gencode__ = {"gtk_action_set_tooltip((GtkAction*)({* id *}), (const gchar*)({* property.value *}))"} },
    visible                = {__type__="gboolean"        ,__default__ = "TRUE"  , __gencode__ = {"gtk_action_set_visible((GtkAction*)({* id *}), (gboolean)({* property.value *}))"} },
    ["visible-horizontal"] = {__type__="gboolean"        ,__default__ = "TRUE"  , __gencode__ = {"gtk_action_set_visible_horizontal((GtkAction*)({* id *}), (gboolean)({* property.value *}))"} },
    ["visible-overflown"]  = {__type__="gboolean"        ,__default__ = "TRUE"  ,rwflags="rw" },
    ["visible-vertical"]   = {__type__="gboolean"        ,__default__ = "TRUE"  , __gencode__ = {"gtk_action_set_visible_vertical((GtkAction*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = nil, 
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkActionGroup
Gtk324.GtkActionGroup = {
  class = "GtkActionGroup", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_action_group_new((const gchar*)({* this.name.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"name"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    get_action = {"GtkAction*", {"GtkActionGroup*", "const gchar*"}, {"action_group", "action_name"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['connect-proxy']    = {ret_type = "void", params = {type = {"GtkActionGroup*", "GtkAction*", "GtkWidget*"}, name ={"actiongroup", "action", "proxy"}} }, 
    ['disconnect-proxy'] = {ret_type = "void", params = {type = {"GtkActionGroup*", "GtkAction*", "GtkWidget*"}, name ={"actiongroup", "action", "proxy"}} }, 
    ['post-activate']    = {ret_type = "void", params = {type = {"GtkActionGroup*", "GtkAction*"}, name ={"actiongroup", "action"}} }, 
    ['pre-activate']     = {ret_type = "void", params = {type = {"GtkActionGroup*", "GtkAction*"}, name ={"actiongroup", "action"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["accel-group"] = {__type__="GtkAccelGroup*"                       , __gencode__ = {"gtk_action_group_set_accel_group((GtkActionGroup*)({* id *}), (GtkAccelGroup*)({* property.value *}))"} },
    name            = {__type__="gchar*"         ,__default__ = "NULL" ,rwflags="rw" },
    sensitive       = {__type__="gboolean"       ,__default__ = "TRUE" , __gencode__ = {"gtk_action_group_set_sensitive((GtkActionGroup*)({* id *}), (gboolean)({* property.value *}))"} },
    visible         = {__type__="gboolean"       ,__default__ = "TRUE" , __gencode__ = {"gtk_action_group_set_visible((GtkActionGroup*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = nil, 
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkAdjustment
Gtk324.GtkAdjustment = {
  class = "GtkAdjustment", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_adjustment_new((gdouble)({* this.value.value *}), (gdouble)({* this.lower.value *}), (gdouble)({* this.upper.value *}), (gdouble)({* this['step-increment'].value *}), (gdouble)({* this['page-increment'].value *}), (gdouble)({* this['page-size'].value *}))", 
            params = { type = {"gdouble", "gdouble", "gdouble", "gdouble", "gdouble", "gdouble"}, 
                       name = {"value", "lower", "upper", "step-increment", "page-increment", "page-size"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    changed       = {"void", {"GtkAdjustment*"}, {"adjustment"} }, 
    value_changed = {"void", {"GtkAdjustment*"}, {"adjustment"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed           = {ret_type = "void", params = {type = {"GtkAdjustment*"}, name ={"adjustment"}} }, 
    ['value-changed'] = {ret_type = "void", params = {type = {"GtkAdjustment*"}, name ={"adjustment"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    lower              = {__type__="gdouble" ,__default__ = "0" , __gencode__ = {"gtk_adjustment_set_lower((GtkAdjustment*)({* id *}), (gdouble)({* property.value *}))"} },
    ["page-increment"] = {__type__="gdouble" ,__default__ = "0" , __gencode__ = {"gtk_adjustment_set_page_increment((GtkAdjustment*)({* id *}), (gdouble)({* property.value *}))"} },
    ["page-size"]      = {__type__="gdouble" ,__default__ = "0" , __gencode__ = {"gtk_adjustment_set_page_size((GtkAdjustment*)({* id *}), (gdouble)({* property.value *}))"} },
    ["step-increment"] = {__type__="gdouble" ,__default__ = "0" , __gencode__ = {"gtk_adjustment_set_step_increment((GtkAdjustment*)({* id *}), (gdouble)({* property.value *}))"} },
    upper              = {__type__="gdouble" ,__default__ = "0" , __gencode__ = {"gtk_adjustment_set_upper((GtkAdjustment*)({* id *}), (gdouble)({* property.value *}))"} },
    value              = {__type__="gdouble" ,__default__ = "0" , __gencode__ = {"gtk_adjustment_set_value((GtkAdjustment*)({* id *}), (gdouble)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkApplication
Gtk324.GtkApplication = {
  class = "GtkApplication", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_application_new((const gchar*)({* this.application_id.value *}), (GApplicationFlags)({* this.flags.value *}))", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    window_added   = {"void", {"GtkApplication*", "GtkWindow*"}, {"application", "window"} }, 
    window_removed = {"void", {"GtkApplication*", "GtkWindow*"}, {"application", "window"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['query-end']      = {ret_type = "void", params = {type = {"GtkApplication*"}, name ={"application"}} }, 
    ['window-added']   = {ret_type = "void", params = {type = {"GtkApplication*", "GtkWindow*"}, name ={"application", "window"}} }, 
    ['window-removed'] = {ret_type = "void", params = {type = {"GtkApplication*", "GtkWindow*"}, name ={"application", "window"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["active-window"]      = {__type__="GtkWindow*"                          },
    ["app-menu"]           = {__type__="GMenuModel*"                        , __gencode__ = {"gtk_application_set_app_menu((GtkApplication*)({* id *}), (GMenuModel*)({* property.value *}))"} },
    menubar                = {__type__="GMenuModel*"                        , __gencode__ = {"gtk_application_set_menubar((GtkApplication*)({* id *}), (GMenuModel*)({* property.value *}))"} },
    ["register-session"]   = {__type__="gboolean"    ,__default__ = "FALSE" ,rwflags="rw" },
    ["screensaver-active"] = {__type__="gboolean"    ,__default__ = "FALSE"  },
  },
  parent = nil, 
};

---------------------  GtkBuilder
Gtk324.GtkBuilder = {
  class = "GtkBuilder", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_builder_new()", 
            params = { type = {}, name = {} } },
    new_from_file     = { gencode = "gtk_builder_new_from_file((const gchar*)({* this.filename.value *}))", 
            params = { type = {}, name = {} } },
    new_from_resource = { gencode = "gtk_builder_new_from_resource((const gchar*)({* this.resource_path.value *}))", 
            params = { type = {}, name = {} } },
    new_from_string   = { gencode = "gtk_builder_new_from_string((const gchar*)({* this.string.value *}), (gssize)({* this.length.value *}))", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    get_type_from_name = {"GType", {"GtkBuilder*", "const char*"}, {"builder", "type_name"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["translation-domain"] = {__type__="gchar*" ,__default__ = "NULL" , __gencode__ = {"gtk_builder_set_translation_domain((GtkBuilder*)({* id *}), (const gchar*)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkCellArea
Gtk324.GtkCellArea = {
  class = "GtkCellArea", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate                       = {"gboolean"           , {"GtkCellArea*", "GtkCellAreaContext*", "GtkWidget*", "const GdkRectangle*", "GtkCellRendererState", "gboolean"}, {"area", "context", "widget", "cell_area", "flags", "edit_only"} }, 
    add                            = {"void"               , {"GtkCellArea*", "GtkCellRenderer*"}, {"area", "renderer"} }, 
    apply_attributes               = {"void"               , {"GtkCellArea*", "GtkTreeModel*", "GtkTreeIter*", "gboolean", "gboolean"}, {"area", "tree_model", "iter", "is_expander", "is_expanded"} }, 
    copy_context                   = {"GtkCellAreaContext*", {"GtkCellArea*", "GtkCellAreaContext*"}, {"area", "context"} }, 
    create_context                 = {"GtkCellAreaContext*", {"GtkCellArea*"}, {"area"} }, 
    event                          = {"gint"               , {"GtkCellArea*", "GtkCellAreaContext*", "GtkWidget*", "GdkEvent*", "const GdkRectangle*", "GtkCellRendererState"}, {"area", "context", "widget", "event", "cell_area", "flags"} }, 
    focus                          = {"gboolean"           , {"GtkCellArea*", "GtkDirectionType"}, {"area", "direction"} }, 
    foreach                        = {"void"               , {"GtkCellArea*", "GtkCellCallback", "gpointer"}, {"area", "callback", "callback_data"} }, 
    foreach_alloc                  = {"void"               , {"GtkCellArea*", "GtkCellAreaContext*", "GtkWidget*", "const GdkRectangle*", "const GdkRectangle*", "GtkCellAllocCallback", "gpointer"}, {"area", "context", "widget", "cell_area", "background_area", "callback", "callback_data"} }, 
    get_cell_property              = {"void"               , {"GtkCellArea*", "GtkCellRenderer*", "guint", "GValue*", "GParamSpec*"}, {"area", "renderer", "property_id", "value", "pspec"} }, 
    get_preferred_height           = {"void"               , {"GtkCellArea*", "GtkCellAreaContext*", "GtkWidget*", "gint*", "gint*"}, {"area", "context", "widget", "minimum_height", "natural_height"} }, 
    get_preferred_height_for_width = {"void"               , {"GtkCellArea*", "GtkCellAreaContext*", "GtkWidget*", "gint", "gint*", "gint*"}, {"area", "context", "widget", "width", "minimum_height", "natural_height"} }, 
    get_preferred_width            = {"void"               , {"GtkCellArea*", "GtkCellAreaContext*", "GtkWidget*", "gint*", "gint*"}, {"area", "context", "widget", "minimum_width", "natural_width"} }, 
    get_preferred_width_for_height = {"void"               , {"GtkCellArea*", "GtkCellAreaContext*", "GtkWidget*", "gint", "gint*", "gint*"}, {"area", "context", "widget", "height", "minimum_width", "natural_width"} }, 
    get_request_mode               = {"GtkSizeRequestMode" , {"GtkCellArea*"}, {"area"} }, 
    is_activatable                 = {"gboolean"           , {"GtkCellArea*"}, {"area"} }, 
    remove                         = {"void"               , {"GtkCellArea*", "GtkCellRenderer*"}, {"area", "renderer"} }, 
    render                         = {"void"               , {"GtkCellArea*", "GtkCellAreaContext*", "GtkWidget*", "cairo_t*", "const GdkRectangle*", "const GdkRectangle*", "GtkCellRendererState", "gboolean"}, {"area", "context", "widget", "cr", "background_area", "cell_area", "flags", "paint_focus"} }, 
    set_cell_property              = {"void"               , {"GtkCellArea*", "GtkCellRenderer*", "guint", "const GValue*", "GParamSpec*"}, {"area", "renderer", "property_id", "value", "pspec"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['add-editable']     = {ret_type = "void", params = {type = {"GtkCellArea*", "GtkCellRenderer*", "GtkCellEditable*", "GdkRectangle*", "gchar*"}, name ={"cellarea", "renderer", "editable", "cell_area", "path"}} }, 
    ['apply-attributes'] = {ret_type = "void", params = {type = {"GtkCellArea*", "GtkTreeModel*", "GtkTreeIter*", "gboolean", "gboolean"}, name ={"cellarea", "model", "iter", "is_expander", "is_expanded"}} }, 
    ['focus-changed']    = {ret_type = "void", params = {type = {"GtkCellArea*", "GtkCellRenderer*", "gchar*"}, name ={"cellarea", "renderer", "path"}} }, 
    ['remove-editable']  = {ret_type = "void", params = {type = {"GtkCellArea*", "GtkCellRenderer*", "GtkCellEditable*"}, name ={"cellarea", "renderer", "editable"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["edit-widget"] = {__type__="GtkCellEditable*"  },
    ["edited-cell"] = {__type__="GtkCellRenderer*"  },
    ["focus-cell"]  = {__type__="GtkCellRenderer*" , __gencode__ = {"gtk_cell_area_set_focus_cell((GtkCellArea*)({* id *}), (GtkCellRenderer*)({* property.value *}))"} },
  },
  parent = nil, 
  implement = {Gtk324.GtkBuildable, Gtk324.GtkCellLayout}, 
};

---------------------  GtkCellAreaContext
Gtk324.GtkCellAreaContext = {
  class = "GtkCellAreaContext", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    allocate                       = {"void", {"GtkCellAreaContext*", "gint", "gint"}, {"context", "width", "height"} }, 
    get_preferred_height_for_width = {"void", {"GtkCellAreaContext*", "gint", "gint*", "gint*"}, {"context", "width", "minimum_height", "natural_height"} }, 
    get_preferred_width_for_height = {"void", {"GtkCellAreaContext*", "gint", "gint*", "gint*"}, {"context", "height", "minimum_width", "natural_width"} }, 
    reset                          = {"void", {"GtkCellAreaContext*"}, {"context"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    area               = {__type__="GtkCellArea*"                     ,rwflags="rw" },
    ["minimum-height"] = {__type__="gint"         ,__default__ = "-1"  },
    ["minimum-width"]  = {__type__="gint"         ,__default__ = "-1"  },
    ["natural-height"] = {__type__="gint"         ,__default__ = "-1"  },
    ["natural-width"]  = {__type__="gint"         ,__default__ = "-1"  },
  },
  parent = nil, 
};

---------------------  GtkCellRenderer
Gtk324.GtkCellRenderer = {
  class = "GtkCellRenderer", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate                       = {"gboolean"          , {"GtkCellRenderer*", "GdkEvent*", "GtkWidget*", "const gchar*", "const GdkRectangle*", "const GdkRectangle*", "GtkCellRendererState"}, {"cell", "event", "widget", "path", "background_area", "cell_area", "flags"} }, 
    editing_canceled               = {"void"              , {"GtkCellRenderer*"}, {"cell"} }, 
    editing_started                = {"void"              , {"GtkCellRenderer*", "GtkCellEditable*", "const gchar*"}, {"cell", "editable", "path"} }, 
    get_aligned_area               = {"void"              , {"GtkCellRenderer*", "GtkWidget*", "GtkCellRendererState", "const GdkRectangle*", "GdkRectangle*"}, {"cell", "widget", "flags", "cell_area", "aligned_area"} }, 
    get_preferred_height           = {"void"              , {"GtkCellRenderer*", "GtkWidget*", "gint*", "gint*"}, {"cell", "widget", "minimum_size", "natural_size"} }, 
    get_preferred_height_for_width = {"void"              , {"GtkCellRenderer*", "GtkWidget*", "gint", "gint*", "gint*"}, {"cell", "widget", "width", "minimum_height", "natural_height"} }, 
    get_preferred_width            = {"void"              , {"GtkCellRenderer*", "GtkWidget*", "gint*", "gint*"}, {"cell", "widget", "minimum_size", "natural_size"} }, 
    get_preferred_width_for_height = {"void"              , {"GtkCellRenderer*", "GtkWidget*", "gint", "gint*", "gint*"}, {"cell", "widget", "height", "minimum_width", "natural_width"} }, 
    get_request_mode               = {"GtkSizeRequestMode", {"GtkCellRenderer*"}, {"cell"} }, 
    get_size                       = {"void"              , {"GtkCellRenderer*", "GtkWidget*", "const GdkRectangle*", "gint*", "gint*", "gint*", "gint*"}, {"cell", "widget", "cell_area", "x_offset", "y_offset", "width", "height"} }, 
    render                         = {"void"              , {"GtkCellRenderer*", "cairo_t*", "GtkWidget*", "const GdkRectangle*", "const GdkRectangle*", "GtkCellRendererState"}, {"cell", "cr", "widget", "background_area", "cell_area", "flags"} }, 
    start_editing                  = {"GtkCellEditable*"  , {"GtkCellRenderer*", "GdkEvent*", "GtkWidget*", "const gchar*", "const GdkRectangle*", "const GdkRectangle*", "GtkCellRendererState"}, {"cell", "event", "widget", "path", "background_area", "cell_area", "flags"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['editing-canceled'] = {ret_type = "void", params = {type = {"GtkCellRenderer*"}, name ={"cellrenderer"}} }, 
    ['editing-started']  = {ret_type = "void", params = {type = {"GtkCellRenderer*", "GtkCellEditable*", "gchar*"}, name ={"cellrenderer", "editable", "path"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["cell-background"]      = {__type__="gchar*"              ,__default__ = "NULL"                         ,rwflags="w" },
    ["cell-background-gdk"]  = {__type__="GdkColor*"                                                         ,rwflags="rw" },
    ["cell-background-rgba"] = {__type__="GdkRGBA*"                                                          ,rwflags="rw" },
    ["cell-background-set"]  = {__type__="gboolean"            ,__default__ = "FALSE"                        ,rwflags="rw" },
    editing                  = {__type__="gboolean"            ,__default__ = "FALSE"                         },
    height                   = {__type__="gint"                ,__default__ = "-1"                           ,rwflags="rw" },
    ["is-expanded"]          = {__type__="gboolean"            ,__default__ = "FALSE"                        ,rwflags="rw" },
    ["is-expander"]          = {__type__="gboolean"            ,__default__ = "FALSE"                        ,rwflags="rw" },
    mode                     = {__type__="GtkCellRendererMode" ,__default__ = "GTK_CELL_RENDERER_MODE_INERT" ,rwflags="rw" },
    sensitive                = {__type__="gboolean"            ,__default__ = "TRUE"                         , __gencode__ = {"gtk_cell_renderer_set_sensitive((GtkCellRenderer*)({* id *}), (gboolean)({* property.value *}))"} },
    visible                  = {__type__="gboolean"            ,__default__ = "TRUE"                         , __gencode__ = {"gtk_cell_renderer_set_visible((GtkCellRenderer*)({* id *}), (gboolean)({* property.value *}))"} },
    width                    = {__type__="gint"                ,__default__ = "-1"                           ,rwflags="rw" },
    xalign                   = {__type__="gfloat"              ,__default__ = "0.5"                          ,rwflags="rw" },
    xpad                     = {__type__="guint"               ,__default__ = "0"                            ,rwflags="rw" },
    yalign                   = {__type__="gfloat"              ,__default__ = "0.5"                          ,rwflags="rw" },
    ypad                     = {__type__="guint"               ,__default__ = "0"                            ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkClipboard
Gtk324.GtkClipboard = {
  class = "GtkClipboard", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['owner-change'] = {ret_type = "void", params = {type = {"GtkClipboard*", "GdkEventOwnerChange*"}, name ={"clipboard", "event"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkCssProvider
Gtk324.GtkCssProvider = {
  class = "GtkCssProvider", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_css_provider_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    parsing_error = {"void", {"GtkCssProvider*", "GtkCssSection*", "const GError*"}, {"provider", "section", "error"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['parsing-error'] = {ret_type = "void", params = {type = {"GtkCssProvider*", "GtkCssSection*", "GError*"}, name ={"cssprovider", "section", "error"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
  implement = {Gtk324.GtkStyleProvider}, 
};

---------------------  GtkEntryBuffer
Gtk324.GtkEntryBuffer = {
  class = "GtkEntryBuffer", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_entry_buffer_new((const gchar*)({* this.initial_chars.value *}), (gint)({* this.n_initial_chars.value *}))", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    delete_text   = {"guint"       , {"GtkEntryBuffer*", "guint", "guint"}, {"buffer", "position", "n_chars"} }, 
    deleted_text  = {"void"        , {"GtkEntryBuffer*", "guint", "guint"}, {"buffer", "position", "n_chars"} }, 
    get_length    = {"guint"       , {"GtkEntryBuffer*"}, {"buffer"} }, 
    get_text      = {"const gchar*", {"GtkEntryBuffer*", "gsize*"}, {"buffer", "n_bytes"} }, 
    insert_text   = {"guint"       , {"GtkEntryBuffer*", "guint", "const gchar*", "guint"}, {"buffer", "position", "chars", "n_chars"} }, 
    inserted_text = {"void"        , {"GtkEntryBuffer*", "guint", "const gchar*", "guint"}, {"buffer", "position", "chars", "n_chars"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['deleted-text']  = {ret_type = "void", params = {type = {"GtkEntryBuffer*", "guint", "guint"}, name ={"entrybuffer", "position", "n_chars"}} }, 
    ['inserted-text'] = {ret_type = "void", params = {type = {"GtkEntryBuffer*", "guint", "gchar*", "guint"}, name ={"entrybuffer", "position", "chars", "n_chars"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    length         = {__type__="guint"  ,__default__ = "0"     },
    ["max-length"] = {__type__="gint"   ,__default__ = "0"    , __gencode__ = {"gtk_entry_buffer_set_max_length((GtkEntryBuffer*)({* id *}), (gint)({* property.value *}))"} },
    text           = {__type__="gchar*" ,__default__ = "\"\"" , __gencode__ = {"gtk_entry_buffer_set_text((GtkEntryBuffer*)({* id *}), (const gchar*)({* property.value *}), (gint)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkEntryCompletion
Gtk324.GtkEntryCompletion = {
  class = "GtkEntryCompletion", 
  constructor = { 
    -- 名称[- ==> _], 
    new           = { gencode = "gtk_entry_completion_new()", 
            params = { type = {}, name = {} } },
    new_with_area = { gencode = "gtk_entry_completion_new_with_area((GtkCellArea*)({* this.area.value *}))", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    action_activated = {"void"    , {"GtkEntryCompletion*", "gint"}, {"completion", "index_"} }, 
    cursor_on_match  = {"gboolean", {"GtkEntryCompletion*", "GtkTreeModel*", "GtkTreeIter*"}, {"completion", "model", "iter"} }, 
    insert_prefix    = {"gboolean", {"GtkEntryCompletion*", "const gchar*"}, {"completion", "prefix"} }, 
    match_selected   = {"gboolean", {"GtkEntryCompletion*", "GtkTreeModel*", "GtkTreeIter*"}, {"completion", "model", "iter"} }, 
    no_matches       = {"void"    , {"GtkEntryCompletion*"}, {"completion"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['action-activated'] = {ret_type = "void"    , params = {type = {"GtkEntryCompletion*", "gint"}, name ={"entrycompletion", "index"}} }, 
    ['cursor-on-match']  = {ret_type = "gboolean", params = {type = {"GtkEntryCompletion*", "GtkTreeModel*", "GtkTreeIter*"}, name ={"entrycompletion", "model", "iter"}} }, 
    ['insert-prefix']    = {ret_type = "gboolean", params = {type = {"GtkEntryCompletion*", "gchar*"}, name ={"entrycompletion", "prefix"}} }, 
    ['match-selected']   = {ret_type = "gboolean", params = {type = {"GtkEntryCompletion*", "GtkTreeModel*", "GtkTreeIter*"}, name ={"entrycompletion", "model", "iter"}} }, 
    ['no-matches']       = {ret_type = "void"    , params = {type = {"GtkEntryCompletion*"}, name ={"entrycompletion"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["cell-area"]          = {__type__="GtkCellArea*"                         ,rwflags="rw" },
    ["inline-completion"]  = {__type__="gboolean"      ,__default__ = "FALSE" , __gencode__ = {"gtk_entry_completion_set_inline_completion((GtkEntryCompletion*)({* id *}), (gboolean)({* property.value *}))"} },
    ["inline-selection"]   = {__type__="gboolean"      ,__default__ = "FALSE" , __gencode__ = {"gtk_entry_completion_set_inline_selection((GtkEntryCompletion*)({* id *}), (gboolean)({* property.value *}))"} },
    ["minimum-key-length"] = {__type__="gint"          ,__default__ = "1"     , __gencode__ = {"gtk_entry_completion_set_minimum_key_length((GtkEntryCompletion*)({* id *}), (gint)({* property.value *}))"} },
    model                  = {__type__="GtkTreeModel*"                        , __gencode__ = {"gtk_entry_completion_set_model((GtkEntryCompletion*)({* id *}), (GtkTreeModel*)({* property.value *}))"} },
    ["popup-completion"]   = {__type__="gboolean"      ,__default__ = "TRUE"  , __gencode__ = {"gtk_entry_completion_set_popup_completion((GtkEntryCompletion*)({* id *}), (gboolean)({* property.value *}))"} },
    ["popup-set-width"]    = {__type__="gboolean"      ,__default__ = "TRUE"  , __gencode__ = {"gtk_entry_completion_set_popup_set_width((GtkEntryCompletion*)({* id *}), (gboolean)({* property.value *}))"} },
    ["popup-single-match"] = {__type__="gboolean"      ,__default__ = "TRUE"  , __gencode__ = {"gtk_entry_completion_set_popup_single_match((GtkEntryCompletion*)({* id *}), (gboolean)({* property.value *}))"} },
    ["text-column"]        = {__type__="gint"          ,__default__ = "-1"    , __gencode__ = {"gtk_entry_completion_set_text_column((GtkEntryCompletion*)({* id *}), (gint)({* property.value *}))"} },
  },
  parent = nil, 
  implement = {Gtk324.GtkBuildable, Gtk324.GtkCellLayout}, 
};

---------------------  GtkEntryIconAccessible
Gtk324.GtkEntryIconAccessible = {
  class = "GtkEntryIconAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkEventController
Gtk324.GtkEventController = {
  class = "GtkEventController", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["propagation-phase"] = {__type__="GtkPropagationPhase" ,__default__ = "GTK_PHASE_BUBBLE" , __gencode__ = {"gtk_event_controller_set_propagation_phase((GtkEventController*)({* id *}), (GtkPropagationPhase)({* property.value *}))"} },
    widget                = {__type__="GtkWidget*"                                            ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkFileFilter
Gtk324.GtkFileFilter = {
  class = "GtkFileFilter", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_file_filter_new()", 
            params = { type = {}, name = {} } },
    new_from_gvariant = { gencode = "gtk_file_filter_new_from_gvariant((GVariant*)({* this.variant.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkIMContext
Gtk324.GtkIMContext = {
  class = "GtkIMContext", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    commit               = {"void"    , {"GtkIMContext*", "const gchar*"}, {"context", "str"} }, 
    delete_surrounding   = {"gboolean", {"GtkIMContext*", "gint", "gint"}, {"context", "offset", "n_chars"} }, 
    filter_keypress      = {"gboolean", {"GtkIMContext*", "GdkEventKey*"}, {"context", "event"} }, 
    focus_in             = {"void"    , {"GtkIMContext*"}, {"context"} }, 
    focus_out            = {"void"    , {"GtkIMContext*"}, {"context"} }, 
    get_preedit_string   = {"void"    , {"GtkIMContext*", "gchar**", "PangoAttrList**", "gint*"}, {"context", "str", "attrs", "cursor_pos"} }, 
    get_surrounding      = {"gboolean", {"GtkIMContext*", "gchar**", "gint*"}, {"context", "text", "cursor_index"} }, 
    preedit_changed      = {"void"    , {"GtkIMContext*"}, {"context"} }, 
    preedit_end          = {"void"    , {"GtkIMContext*"}, {"context"} }, 
    preedit_start        = {"void"    , {"GtkIMContext*"}, {"context"} }, 
    reset                = {"void"    , {"GtkIMContext*"}, {"context"} }, 
    retrieve_surrounding = {"gboolean", {"GtkIMContext*"}, {"context"} }, 
    set_client_window    = {"void"    , {"GtkIMContext*", "GdkWindow*"}, {"context", "window"} }, 
    set_cursor_location  = {"void"    , {"GtkIMContext*", "GdkRectangle*"}, {"context", "area"} }, 
    set_surrounding      = {"void"    , {"GtkIMContext*", "const gchar*", "gint", "gint"}, {"context", "text", "len", "cursor_index"} }, 
    set_use_preedit      = {"void"    , {"GtkIMContext*", "gboolean"}, {"context", "use_preedit"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    commit                   = {ret_type = "void"    , params = {type = {"GtkIMContext*", "const gchar*"}, name ={"context", "str"}} }, 
    ['delete-surrounding']   = {ret_type = "gboolean", params = {type = {"GtkIMContext*", "gint", "gint"}, name ={"imcontext", "offset", "n_chars"}} }, 
    ['preedit-changed']      = {ret_type = "void"    , params = {type = {"GtkIMContext*"}, name ={"imcontext"}} }, 
    ['preedit-end']          = {ret_type = "void"    , params = {type = {"GtkIMContext*"}, name ={"imcontext"}} }, 
    ['preedit-start']        = {ret_type = "void"    , params = {type = {"GtkIMContext*"}, name ={"imcontext"}} }, 
    ['retrieve-surrounding'] = {ret_type = "gboolean", params = {type = {"GtkIMContext*"}, name ={"imcontext"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["input-hints"]   = {__type__="GtkInputHints"                                                ,rwflags="rw" },
    ["input-purpose"] = {__type__="GtkInputPurpose" ,__default__ = "GTK_INPUT_PURPOSE_FREE_FORM" ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkIconFactory
Gtk324.GtkIconFactory = {
  class = "GtkIconFactory", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_icon_factory_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkIconInfo
Gtk324.GtkIconInfo = {
  class = "GtkIconInfo", 
  constructor = { 
    -- 名称[- ==> _], 
    new_for_pixbuf = { gencode = "gtk_icon_info_new_for_pixbuf((GtkIconTheme*)({* this.icon_theme.value *}), (GdkPixbuf*)({* this.pixbuf.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkIconTheme
Gtk324.GtkIconTheme = {
  class = "GtkIconTheme", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_icon_theme_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    changed = {"void", {"GtkIconTheme*"}, {"icon_theme"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed = {ret_type = "void", params = {type = {"GtkIconTheme*"}, name ={"icon_theme"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkListStore
Gtk324.GtkListStore = {
  class = "GtkListStore", 
  constructor = { 
    -- 名称[- ==> _], 
    new  = { gencode = "gtk_list_store_new((gint)({* this.n_columns.value *}), 0)", 
            params = { type = {}, name = {} } },
    newv = { gencode = "gtk_list_store_newv((gint)({* this.n_columns.value *}), (GType*)({* this.types.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
  implement = {Gtk324.GtkBuildable, Gtk324.GtkTreeDragDest, Gtk324.GtkTreeDragSource, Gtk324.GtkTreeModel, Gtk324.GtkTreeSortable}, 
};

---------------------  GtkMountOperation
Gtk324.GtkMountOperation = {
  class = "GtkMountOperation", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_mount_operation_new((GtkWindow*)({* this.parent.value *}))", 
            params = { type = {"GtkWindow*"}, 
                       name = {"parent"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["is-showing"] = {__type__="gboolean"   ,__default__ = "FALSE"  },
    parent         = {__type__="GtkWindow*"                        , __gencode__ = {"gtk_mount_operation_set_parent((GtkMountOperation*)({* id *}), (GtkWindow*)({* property.value *}))"} },
    screen         = {__type__="GdkScreen*"                        , __gencode__ = {"gtk_mount_operation_set_screen((GtkMountOperation*)({* id *}), (GdkScreen*)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkNativeDialog
Gtk324.GtkNativeDialog = {
  class = "GtkNativeDialog", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    hide     = {"void", {"GtkNativeDialog*"}, {"self"} }, 
    response = {"void", {"GtkNativeDialog*", "gint"}, {"self", "response_id"} }, 
    show     = {"void", {"GtkNativeDialog*"}, {"self"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    response = {ret_type = "void", params = {type = {"GtkNativeDialog*", "gint"}, name ={"self", "response_id"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    modal             = {__type__="gboolean"   , __gencode__ = {"gtk_native_dialog_set_modal((GtkNativeDialog*)({* id *}), (gboolean)({* property.value *}))"} },
    title             = {__type__="gchar*"     , __gencode__ = {"gtk_native_dialog_set_title((GtkNativeDialog*)({* id *}), (const char*)({* property.value *}))"} },
    ["transient-for"] = {__type__="GtkWindow*" , __gencode__ = {"gtk_native_dialog_set_transient_for((GtkNativeDialog*)({* id *}), (GtkWindow*)({* property.value *}))"},__construct__= 1 },
    visible           = {__type__="gboolean"    },
  },
  parent = nil, 
};

---------------------  GtkNotebookPageAccessible
Gtk324.GtkNotebookPageAccessible = {
  class = "GtkNotebookPageAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_notebook_page_accessible_new((GtkNotebookAccessible*)({* this.notebook.value *}), (GtkWidget*)({* this.child.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkNumerableIcon
Gtk324.GtkNumerableIcon = {
  class = "GtkNumerableIcon", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["background-icon"]      = {__type__="GIcon*"                                 ,rwflags="rw" },
    ["background-icon-name"] = {__type__="gchar*"           ,__default__ = "NULL" , __gencode__ = {"gtk_numerable_icon_set_background_icon_name((GtkNumerableIcon*)({* id *}), (const gchar*)({* property.value *}))"} },
    count                    = {__type__="gint"             ,__default__ = "0"    , __gencode__ = {"gtk_numerable_icon_set_count((GtkNumerableIcon*)({* id *}), (gint)({* property.value *}))"} },
    label                    = {__type__="gchar*"           ,__default__ = "NULL" , __gencode__ = {"gtk_numerable_icon_set_label((GtkNumerableIcon*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["style-context"]        = {__type__="GtkStyleContext*"                       , __gencode__ = {"gtk_numerable_icon_set_style_context((GtkNumerableIcon*)({* id *}), (GtkStyleContext*)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkPageSetup
Gtk324.GtkPageSetup = {
  class = "GtkPageSetup", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_page_setup_new()", 
            params = { type = {}, name = {} } },
    new_from_file     = { gencode = "gtk_page_setup_new_from_file((const gchar*)({* this.file_name.value *}))", 
            params = { type = {}, name = {} } },
    new_from_gvariant = { gencode = "gtk_page_setup_new_from_gvariant((GVariant*)({* this.variant.value *}))", 
            params = { type = {}, name = {} } },
    new_from_key_file = { gencode = "gtk_page_setup_new_from_key_file((GKeyFile*)({* this.key_file.value *}), (const gchar*)({* this.group_name.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkPrintContext
Gtk324.GtkPrintContext = {
  class = "GtkPrintContext", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkPrintOperation
Gtk324.GtkPrintOperation = {
  class = "GtkPrintOperation", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_print_operation_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    begin_print          = {"void"      , {"GtkPrintOperation*", "GtkPrintContext*"}, {"operation", "context"} }, 
    create_custom_widget = {"GtkWidget*", {"GtkPrintOperation*"}, {"operation"} }, 
    custom_widget_apply  = {"void"      , {"GtkPrintOperation*", "GtkWidget*"}, {"operation", "widget"} }, 
    done                 = {"void"      , {"GtkPrintOperation*", "GtkPrintOperationResult"}, {"operation", "result"} }, 
    draw_page            = {"void"      , {"GtkPrintOperation*", "GtkPrintContext*", "gint"}, {"operation", "context", "page_nr"} }, 
    end_print            = {"void"      , {"GtkPrintOperation*", "GtkPrintContext*"}, {"operation", "context"} }, 
    paginate             = {"gboolean"  , {"GtkPrintOperation*", "GtkPrintContext*"}, {"operation", "context"} }, 
    preview              = {"gboolean"  , {"GtkPrintOperation*", "GtkPrintOperationPreview*", "GtkPrintContext*", "GtkWindow*"}, {"operation", "preview", "context", "parent"} }, 
    request_page_setup   = {"void"      , {"GtkPrintOperation*", "GtkPrintContext*", "gint", "GtkPageSetup*"}, {"operation", "context", "page_nr", "setup"} }, 
    status_changed       = {"void"      , {"GtkPrintOperation*"}, {"operation"} }, 
    update_custom_widget = {"void"      , {"GtkPrintOperation*", "GtkWidget*", "GtkPageSetup*", "GtkPrintSettings*"}, {"operation", "widget", "setup", "settings"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['begin-print']          = {ret_type = "void"    , params = {type = {"GtkPrintOperation*", "GtkPrintContext*"}, name ={"printoperation", "context"}} }, 
    ['create-custom-widget'] = {ret_type = "GObject*", params = {type = {"GtkPrintOperation*"}, name ={"printoperation"}} }, 
    ['custom-widget-apply']  = {ret_type = "void"    , params = {type = {"GtkPrintOperation*", "GtkWidget*"}, name ={"printoperation", "widget"}} }, 
    done                     = {ret_type = "void"    , params = {type = {"GtkPrintOperation*", "GtkPrintOperationResult"}, name ={"operation", "result"}} }, 
    ['draw-page']            = {ret_type = "void"    , params = {type = {"GtkPrintOperation*", "GtkPrintContext*", "gint"}, name ={"printoperation", "context", "page_nr"}} }, 
    ['end-print']            = {ret_type = "void"    , params = {type = {"GtkPrintOperation*", "GtkPrintContext*"}, name ={"printoperation", "context"}} }, 
    paginate                 = {ret_type = "gboolean", params = {type = {"GtkPrintOperation*", "GtkPrintContext*"}, name ={"operation", "context"}} }, 
    preview                  = {ret_type = "gboolean", params = {type = {"GtkPrintOperation*", "GtkPrintOperationPreview*", "GtkPrintContext*", "GtkWindow*"}, name ={"operation", "preview", "context", "parent"}} }, 
    ['request-page-setup']   = {ret_type = "void"    , params = {type = {"GtkPrintOperation*", "GtkPrintContext*", "gint", "GtkPageSetup*"}, name ={"printoperation", "context", "page_nr", "setup"}} }, 
    ['status-changed']       = {ret_type = "void"    , params = {type = {"GtkPrintOperation*"}, name ={"printoperation"}} }, 
    ['update-custom-widget'] = {ret_type = "void"    , params = {type = {"GtkPrintOperation*", "GtkWidget*", "GtkPageSetup*", "GtkPrintSettings*"}, name ={"printoperation", "widget", "setup", "settings"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["allow-async"]        = {__type__="gboolean"          ,__default__ = "FALSE"                    , __gencode__ = {"gtk_print_operation_set_allow_async((GtkPrintOperation*)({* id *}), (gboolean)({* property.value *}))"} },
    ["current-page"]       = {__type__="gint"              ,__default__ = "-1"                       , __gencode__ = {"gtk_print_operation_set_current_page((GtkPrintOperation*)({* id *}), (gint)({* property.value *}))"} },
    ["custom-tab-label"]   = {__type__="gchar*"            ,__default__ = "NULL"                     , __gencode__ = {"gtk_print_operation_set_custom_tab_label((GtkPrintOperation*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["default-page-setup"] = {__type__="GtkPageSetup*"                                               , __gencode__ = {"gtk_print_operation_set_default_page_setup((GtkPrintOperation*)({* id *}), (GtkPageSetup*)({* property.value *}))"} },
    ["embed-page-setup"]   = {__type__="gboolean"          ,__default__ = "FALSE"                    , __gencode__ = {"gtk_print_operation_set_embed_page_setup((GtkPrintOperation*)({* id *}), (gboolean)({* property.value *}))"} },
    ["export-filename"]    = {__type__="gchar*"            ,__default__ = "NULL"                     , __gencode__ = {"gtk_print_operation_set_export_filename((GtkPrintOperation*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["has-selection"]      = {__type__="gboolean"          ,__default__ = "FALSE"                    , __gencode__ = {"gtk_print_operation_set_has_selection((GtkPrintOperation*)({* id *}), (gboolean)({* property.value *}))"} },
    ["job-name"]           = {__type__="gchar*"            ,__default__ = "\"\""                     , __gencode__ = {"gtk_print_operation_set_job_name((GtkPrintOperation*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["n-pages"]            = {__type__="gint"              ,__default__ = "-1"                       , __gencode__ = {"gtk_print_operation_set_n_pages((GtkPrintOperation*)({* id *}), (gint)({* property.value *}))"} },
    ["n-pages-to-print"]   = {__type__="gint"              ,__default__ = "-1"                        },
    ["print-settings"]     = {__type__="GtkPrintSettings*"                                           , __gencode__ = {"gtk_print_operation_set_print_settings((GtkPrintOperation*)({* id *}), (GtkPrintSettings*)({* property.value *}))"} },
    ["show-progress"]      = {__type__="gboolean"          ,__default__ = "FALSE"                    , __gencode__ = {"gtk_print_operation_set_show_progress((GtkPrintOperation*)({* id *}), (gboolean)({* property.value *}))"} },
    status                 = {__type__="GtkPrintStatus"    ,__default__ = "GTK_PRINT_STATUS_INITIAL"  },
    ["status-string"]      = {__type__="gchar*"            ,__default__ = "\"\""                      },
    ["support-selection"]  = {__type__="gboolean"          ,__default__ = "FALSE"                    , __gencode__ = {"gtk_print_operation_set_support_selection((GtkPrintOperation*)({* id *}), (gboolean)({* property.value *}))"} },
    ["track-print-status"] = {__type__="gboolean"          ,__default__ = "FALSE"                    , __gencode__ = {"gtk_print_operation_set_track_print_status((GtkPrintOperation*)({* id *}), (gboolean)({* property.value *}))"} },
    unit                   = {__type__="GtkUnit"           ,__default__ = "GTK_UNIT_NONE"            , __gencode__ = {"gtk_print_operation_set_unit((GtkPrintOperation*)({* id *}), (GtkUnit)({* property.value *}))"} },
    ["use-full-page"]      = {__type__="gboolean"          ,__default__ = "FALSE"                    , __gencode__ = {"gtk_print_operation_set_use_full_page((GtkPrintOperation*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = nil, 
  implement = {Gtk324.GtkPrintOperationPreview}, 
};

---------------------  GtkPrintSettings
Gtk324.GtkPrintSettings = {
  class = "GtkPrintSettings", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_print_settings_new()", 
            params = { type = {}, name = {} } },
    new_from_file     = { gencode = "gtk_print_settings_new_from_file((const gchar*)({* this.file_name.value *}))", 
            params = { type = {}, name = {} } },
    new_from_gvariant = { gencode = "gtk_print_settings_new_from_gvariant((GVariant*)({* this.variant.value *}))", 
            params = { type = {}, name = {} } },
    new_from_key_file = { gencode = "gtk_print_settings_new_from_key_file((GKeyFile*)({* this.key_file.value *}), (const gchar*)({* this.group_name.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkRcStyle
Gtk324.GtkRcStyle = {
  class = "GtkRcStyle", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_rc_style_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    create_rc_style = {"GtkRcStyle*", {"GtkRcStyle*"}, {"rc_style"} }, 
    create_style    = {"GtkStyle*"  , {"GtkRcStyle*"}, {"rc_style"} }, 
    merge           = {"void"       , {"GtkRcStyle*", "GtkRcStyle*"}, {"dest", "src"} }, 
    parse           = {"guint"      , {"GtkRcStyle*", "GtkSettings*", "GScanner*"}, {"rc_style", "settings", "scanner"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkRecentFilter
Gtk324.GtkRecentFilter = {
  class = "GtkRecentFilter", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_recent_filter_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkRecentManager
Gtk324.GtkRecentManager = {
  class = "GtkRecentManager", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_recent_manager_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    changed = {"void", {"GtkRecentManager*"}, {"manager"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed = {ret_type = "void", params = {type = {"GtkRecentManager*"}, name ={"manager"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    filename = {__type__="gchar*" ,__default__ = "NULL" ,rwflags="rw" },
    size     = {__type__="gint"   ,__default__ = "0"     },
  },
  parent = nil, 
};

---------------------  GtkSettings
Gtk324.GtkSettings = {
  class = "GtkSettings", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["color-hash"]                        = {__type__="GHashTable*"                                                                                                                                                                                  },
    ["gtk-alternative-button-order"]      = {__type__="gboolean"          ,__default__ = "FALSE"                                                                                                                                                    ,rwflags="rw" },
    ["gtk-alternative-sort-arrows"]       = {__type__="gboolean"          ,__default__ = "FALSE"                                                                                                                                                    ,rwflags="rw" },
    ["gtk-application-prefer-dark-theme"] = {__type__="gboolean"          ,__default__ = "FALSE"                                                                                                                                                    ,rwflags="rw" },
    ["gtk-auto-mnemonics"]                = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-button-images"]                 = {__type__="gboolean"          ,__default__ = "FALSE"                                                                                                                                                    ,rwflags="rw" },
    ["gtk-can-change-accels"]             = {__type__="gboolean"          ,__default__ = "FALSE"                                                                                                                                                    ,rwflags="rw" },
    ["gtk-color-palette"]                 = {__type__="gchar*"            ,__default__ = "\"black:white:gray50:red:purple:blue:light blue:green:yellow:orange:lavender:brown:goldenrod4:dodger blue:pink:light green:gray10:gray30:gray75:gray90\"" ,rwflags="rw" },
    ["gtk-color-scheme"]                  = {__type__="gchar*"            ,__default__ = "\"\""                                                                                                                                                     ,rwflags="rw" },
    ["gtk-cursor-aspect-ratio"]           = {__type__="gfloat"            ,__default__ = "0.04"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-cursor-blink"]                  = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-cursor-blink-time"]             = {__type__="gint"              ,__default__ = "1200"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-cursor-blink-timeout"]          = {__type__="gint"              ,__default__ = "10"                                                                                                                                                       ,rwflags="rw" },
    ["gtk-cursor-theme-name"]             = {__type__="gchar*"            ,__default__ = "NULL"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-cursor-theme-size"]             = {__type__="gint"              ,__default__ = "0"                                                                                                                                                        ,rwflags="rw" },
    ["gtk-decoration-layout"]             = {__type__="gchar*"            ,__default__ = "\"menu:minimize,maximize,close\""                                                                                                                         ,rwflags="rw" },
    ["gtk-dialogs-use-header"]            = {__type__="gboolean"          ,__default__ = "FALSE"                                                                                                                                                    ,rwflags="rw" },
    ["gtk-dnd-drag-threshold"]            = {__type__="gint"              ,__default__ = "8"                                                                                                                                                        ,rwflags="rw" },
    ["gtk-double-click-distance"]         = {__type__="gint"              ,__default__ = "5"                                                                                                                                                        ,rwflags="rw" },
    ["gtk-double-click-time"]             = {__type__="gint"              ,__default__ = "400"                                                                                                                                                      ,rwflags="rw" },
    ["gtk-enable-accels"]                 = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-enable-animations"]             = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-enable-event-sounds"]           = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-enable-input-feedback-sounds"]  = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-enable-mnemonics"]              = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-enable-primary-paste"]          = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-enable-tooltips"]               = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-entry-password-hint-timeout"]   = {__type__="guint"             ,__default__ = "0"                                                                                                                                                        ,rwflags="rw" },
    ["gtk-entry-select-on-focus"]         = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-error-bell"]                    = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-fallback-icon-theme"]           = {__type__="gchar*"            ,__default__ = "NULL"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-file-chooser-backend"]          = {__type__="gchar*"            ,__default__ = "NULL"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-font-name"]                     = {__type__="gchar*"            ,__default__ = "\"Sans 10\""                                                                                                                                              ,rwflags="rw" },
    ["gtk-fontconfig-timestamp"]          = {__type__="guint"             ,__default__ = "0"                                                                                                                                                        ,rwflags="rw" },
    ["gtk-icon-sizes"]                    = {__type__="gchar*"            ,__default__ = "NULL"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-icon-theme-name"]               = {__type__="gchar*"            ,__default__ = "\"Adwaita\""                                                                                                                                              ,rwflags="rw" },
    ["gtk-im-module"]                     = {__type__="gchar*"            ,__default__ = "NULL"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-im-preedit-style"]              = {__type__="GtkIMPreeditStyle" ,__default__ = "GTK_IM_PREEDIT_CALLBACK"                                                                                                                                  ,rwflags="rw" },
    ["gtk-im-status-style"]               = {__type__="GtkIMStatusStyle"  ,__default__ = "GTK_IM_STATUS_CALLBACK"                                                                                                                                   ,rwflags="rw" },
    ["gtk-key-theme-name"]                = {__type__="gchar*"            ,__default__ = "NULL"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-keynav-cursor-only"]            = {__type__="gboolean"          ,__default__ = "FALSE"                                                                                                                                                    ,rwflags="rw" },
    ["gtk-keynav-use-caret"]              = {__type__="gboolean"          ,__default__ = "FALSE"                                                                                                                                                    ,rwflags="rw" },
    ["gtk-keynav-wrap-around"]            = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-label-select-on-focus"]         = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-long-press-time"]               = {__type__="guint"             ,__default__ = "500"                                                                                                                                                      ,rwflags="rw" },
    ["gtk-menu-bar-accel"]                = {__type__="gchar*"            ,__default__ = "\"F10\""                                                                                                                                                  ,rwflags="rw" },
    ["gtk-menu-bar-popup-delay"]          = {__type__="gint"              ,__default__ = "0"                                                                                                                                                        ,rwflags="rw" },
    ["gtk-menu-images"]                   = {__type__="gboolean"          ,__default__ = "FALSE"                                                                                                                                                    ,rwflags="rw" },
    ["gtk-menu-popdown-delay"]            = {__type__="gint"              ,__default__ = "1000"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-menu-popup-delay"]              = {__type__="gint"              ,__default__ = "225"                                                                                                                                                      ,rwflags="rw" },
    ["gtk-modules"]                       = {__type__="gchar*"            ,__default__ = "NULL"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-overlay-scrolling"]             = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-primary-button-warps-slider"]   = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-print-backends"]                = {__type__="gchar*"            ,__default__ = "\"file,cups\""                                                                                                                                            ,rwflags="rw" },
    ["gtk-print-preview-command"]         = {__type__="gchar*"            ,__default__ = "\"evince --unlink-tempfile --preview --print-settings %s %f\""                                                                                            ,rwflags="rw" },
    ["gtk-recent-files-enabled"]          = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-recent-files-limit"]            = {__type__="gint"              ,__default__ = "50"                                                                                                                                                       ,rwflags="rw" },
    ["gtk-recent-files-max-age"]          = {__type__="gint"              ,__default__ = "30"                                                                                                                                                       ,rwflags="rw" },
    ["gtk-scrolled-window-placement"]     = {__type__="GtkCornerType"     ,__default__ = "GTK_CORNER_TOP_LEFT"                                                                                                                                      ,rwflags="rw" },
    ["gtk-shell-shows-app-menu"]          = {__type__="gboolean"          ,__default__ = "FALSE"                                                                                                                                                    ,rwflags="rw" },
    ["gtk-shell-shows-desktop"]           = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-shell-shows-menubar"]           = {__type__="gboolean"          ,__default__ = "FALSE"                                                                                                                                                    ,rwflags="rw" },
    ["gtk-show-input-method-menu"]        = {__type__="gboolean"          ,__default__ = "FALSE"                                                                                                                                                    ,rwflags="rw" },
    ["gtk-show-unicode-menu"]             = {__type__="gboolean"          ,__default__ = "FALSE"                                                                                                                                                    ,rwflags="rw" },
    ["gtk-sound-theme-name"]              = {__type__="gchar*"            ,__default__ = "\"freedesktop\""                                                                                                                                          ,rwflags="rw" },
    ["gtk-split-cursor"]                  = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-theme-name"]                    = {__type__="gchar*"            ,__default__ = "\"Adwaita\""                                                                                                                                              ,rwflags="rw" },
    ["gtk-timeout-expand"]                = {__type__="gint"              ,__default__ = "500"                                                                                                                                                      ,rwflags="rw" },
    ["gtk-timeout-initial"]               = {__type__="gint"              ,__default__ = "500"                                                                                                                                                      ,rwflags="rw" },
    ["gtk-timeout-repeat"]                = {__type__="gint"              ,__default__ = "50"                                                                                                                                                       ,rwflags="rw" },
    ["gtk-titlebar-double-click"]         = {__type__="gchar*"            ,__default__ = "\"toggle-maximize\""                                                                                                                                      ,rwflags="rw" },
    ["gtk-titlebar-middle-click"]         = {__type__="gchar*"            ,__default__ = "\"none\""                                                                                                                                                 ,rwflags="rw" },
    ["gtk-titlebar-right-click"]          = {__type__="gchar*"            ,__default__ = "\"menu\""                                                                                                                                                 ,rwflags="rw" },
    ["gtk-toolbar-icon-size"]             = {__type__="GtkIconSize"       ,__default__ = "GTK_ICON_SIZE_LARGE_TOOLBAR"                                                                                                                              ,rwflags="rw" },
    ["gtk-toolbar-style"]                 = {__type__="GtkToolbarStyle"   ,__default__ = "GTK_TOOLBAR_BOTH_HORIZ"                                                                                                                                   ,rwflags="rw" },
    ["gtk-tooltip-browse-mode-timeout"]   = {__type__="gint"              ,__default__ = "500"                                                                                                                                                      ,rwflags="rw" },
    ["gtk-tooltip-browse-timeout"]        = {__type__="gint"              ,__default__ = "60"                                                                                                                                                       ,rwflags="rw" },
    ["gtk-tooltip-timeout"]               = {__type__="gint"              ,__default__ = "500"                                                                                                                                                      ,rwflags="rw" },
    ["gtk-touchscreen-mode"]              = {__type__="gboolean"          ,__default__ = "FALSE"                                                                                                                                                    ,rwflags="rw" },
    ["gtk-visible-focus"]                 = {__type__="GtkPolicyType"     ,__default__ = "GTK_POLICY_AUTOMATIC"                                                                                                                                     ,rwflags="rw" },
    ["gtk-xft-antialias"]                 = {__type__="gint"              ,__default__ = "-1"                                                                                                                                                       ,rwflags="rw" },
    ["gtk-xft-dpi"]                       = {__type__="gint"              ,__default__ = "-1"                                                                                                                                                       ,rwflags="rw" },
    ["gtk-xft-hinting"]                   = {__type__="gint"              ,__default__ = "-1"                                                                                                                                                       ,rwflags="rw" },
    ["gtk-xft-hintstyle"]                 = {__type__="gchar*"            ,__default__ = "NULL"                                                                                                                                                     ,rwflags="rw" },
    ["gtk-xft-rgba"]                      = {__type__="gchar*"            ,__default__ = "NULL"                                                                                                                                                     ,rwflags="rw" },
  },
  parent = nil, 
  implement = {Gtk324.GtkStyleProvider}, 
};

---------------------  GtkSizeGroup
Gtk324.GtkSizeGroup = {
  class = "GtkSizeGroup", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_size_group_new((GtkSizeGroupMode)({* this.mode.value *}))", 
            params = { type = {"GtkSizeGroupMode"}, 
                       name = {"mode"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["ignore-hidden"] = {__type__="gboolean"         ,__default__ = "FALSE"                     , __gencode__ = {"gtk_size_group_set_ignore_hidden((GtkSizeGroup*)({* id *}), (gboolean)({* property.value *}))"} },
    mode              = {__type__="GtkSizeGroupMode" ,__default__ = "GTK_SIZE_GROUP_HORIZONTAL" , __gencode__ = {"gtk_size_group_set_mode((GtkSizeGroup*)({* id *}), (GtkSizeGroupMode)({* property.value *}))"} },
  },
  parent = nil, 
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkStatusIcon
Gtk324.GtkStatusIcon = {
  class = "GtkStatusIcon", 
  constructor = { 
    -- 名称[- ==> _], 
    new                = { gencode = "gtk_status_icon_new()", 
            params = { type = {}, name = {} } },
    new_from_file      = { gencode = "gtk_status_icon_new_from_file((const gchar*)({* this.filename.value *}))", 
            params = { type = {}, name = {} } },
    new_from_gicon     = { gencode = "gtk_status_icon_new_from_gicon((GIcon*)({* this.icon.value *}))", 
            params = { type = {}, name = {} } },
    new_from_icon_name = { gencode = "gtk_status_icon_new_from_icon_name((const gchar*)({* this['icon-name']value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"icon-name"} } },
    new_from_pixbuf    = { gencode = "gtk_status_icon_new_from_pixbuf((GdkPixbuf*)({* this.pixbuf.value *}))", 
            params = { type = {"GdkPixbuf*"}, 
                       name = {"pixbuf"} } },
    new_from_stock     = { gencode = "gtk_status_icon_new_from_stock((const gchar*)({* this.stock_id.value *}))", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate             = {"void"    , {"GtkStatusIcon*"}, {"status_icon"} }, 
    button_press_event   = {"gboolean", {"GtkStatusIcon*", "GdkEventButton*"}, {"status_icon", "event"} }, 
    button_release_event = {"gboolean", {"GtkStatusIcon*", "GdkEventButton*"}, {"status_icon", "event"} }, 
    popup_menu           = {"void"    , {"GtkStatusIcon*", "guint", "guint32"}, {"status_icon", "button", "activate_time"} }, 
    query_tooltip        = {"gboolean", {"GtkStatusIcon*", "gint", "gint", "gboolean", "GtkTooltip*"}, {"status_icon", "x", "y", "keyboard_mode", "tooltip"} }, 
    scroll_event         = {"gboolean", {"GtkStatusIcon*", "GdkEventScroll*"}, {"status_icon", "event"} }, 
    size_changed         = {"gboolean", {"GtkStatusIcon*", "gint"}, {"status_icon", "size"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate                 = {ret_type = "void"    , params = {type = {"GtkStatusIcon*"}, name ={"status_icon"}} }, 
    ['button-press-event']   = {ret_type = "gboolean", params = {type = {"GtkStatusIcon*", "GdkEventButton*"}, name ={"statusicon", "event"}} }, 
    ['button-release-event'] = {ret_type = "gboolean", params = {type = {"GtkStatusIcon*", "GdkEventButton*"}, name ={"statusicon", "event"}} }, 
    ['popup-menu']           = {ret_type = "void"    , params = {type = {"GtkStatusIcon*", "guint", "guint"}, name ={"statusicon", "button", "activate_time"}} }, 
    ['query-tooltip']        = {ret_type = "gboolean", params = {type = {"GtkStatusIcon*", "gint", "gint", "gboolean", "GtkTooltip*"}, name ={"statusicon", "x", "y", "keyboard_mode", "tooltip"}} }, 
    ['scroll-event']         = {ret_type = "gboolean", params = {type = {"GtkStatusIcon*", "GdkEventScroll*"}, name ={"statusicon", "event"}} }, 
    ['size-changed']         = {ret_type = "gboolean", params = {type = {"GtkStatusIcon*", "gint"}, name ={"statusicon", "size"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    embedded           = {__type__="gboolean"       ,__default__ = "FALSE"                       },
    file               = {__type__="gchar*"         ,__default__ = "NULL"                       , __gencode__ = {"gtk_status_icon_set_from_file((GtkStatusIcon*)({* id *}), (const gchar*)({* property.value *}))"} },
    gicon              = {__type__="GIcon*"                                                     , __gencode__ = {"gtk_status_icon_set_from_gicon((GtkStatusIcon*)({* id *}), (GIcon*)({* property.value *}))"} },
    ["has-tooltip"]    = {__type__="gboolean"       ,__default__ = "FALSE"                      , __gencode__ = {"gtk_status_icon_set_has_tooltip((GtkStatusIcon*)({* id *}), (gboolean)({* property.value *}))"} },
    ["icon-name"]      = {__type__="gchar*"         ,__default__ = "NULL"                       , __gencode__ = {"gtk_status_icon_set_from_icon_name((GtkStatusIcon*)({* id *}), (const gchar*)({* property.value *}))"} },
    orientation        = {__type__="GtkOrientation" ,__default__ = "GTK_ORIENTATION_HORIZONTAL"  },
    pixbuf             = {__type__="GdkPixbuf*"                                                 , __gencode__ = {"gtk_status_icon_set_from_pixbuf((GtkStatusIcon*)({* id *}), (GdkPixbuf*)({* property.value *}))"} },
    screen             = {__type__="GdkScreen*"                                                 , __gencode__ = {"gtk_status_icon_set_screen((GtkStatusIcon*)({* id *}), (GdkScreen*)({* property.value *}))"} },
    size               = {__type__="gint"           ,__default__ = "0"                           },
    stock              = {__type__="gchar*"         ,__default__ = "NULL"                       , __gencode__ = {"gtk_status_icon_set_from_stock((GtkStatusIcon*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["storage-type"]   = {__type__="GtkImageType"   ,__default__ = "GTK_IMAGE_EMPTY"             },
    title              = {__type__="gchar*"         ,__default__ = "NULL"                       , __gencode__ = {"gtk_status_icon_set_title((GtkStatusIcon*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["tooltip-markup"] = {__type__="gchar*"         ,__default__ = "NULL"                       , __gencode__ = {"gtk_status_icon_set_tooltip_markup((GtkStatusIcon*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["tooltip-text"]   = {__type__="gchar*"         ,__default__ = "NULL"                       , __gencode__ = {"gtk_status_icon_set_tooltip_text((GtkStatusIcon*)({* id *}), (const gchar*)({* property.value *}))"} },
    visible            = {__type__="gboolean"       ,__default__ = "TRUE"                       , __gencode__ = {"gtk_status_icon_set_visible((GtkStatusIcon*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkStyle
Gtk324.GtkStyle = {
  class = "GtkStyle", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_style_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    clone            = {"GtkStyle*" , {"GtkStyle*"}, {"style"} }, 
    copy             = {"void"      , {"GtkStyle*", "GtkStyle*"}, {"style", "src"} }, 
    draw_arrow       = {"void"      , {"GtkStyle*", "cairo_t*", "GtkStateType", "GtkShadowType", "GtkWidget*", "const gchar*", "GtkArrowType", "gboolean", "gint", "gint", "gint", "gint"}, {"style", "cr", "state_type", "shadow_type", "widget", "detail", "arrow_type", "fill", "x", "y", "width", "height"} }, 
    draw_box         = {"void"      , {"GtkStyle*", "cairo_t*", "GtkStateType", "GtkShadowType", "GtkWidget*", "const gchar*", "gint", "gint", "gint", "gint"}, {"style", "cr", "state_type", "shadow_type", "widget", "detail", "x", "y", "width", "height"} }, 
    draw_box_gap     = {"void"      , {"GtkStyle*", "cairo_t*", "GtkStateType", "GtkShadowType", "GtkWidget*", "const gchar*", "gint", "gint", "gint", "gint", "GtkPositionType", "gint", "gint"}, {"style", "cr", "state_type", "shadow_type", "widget", "detail", "x", "y", "width", "height", "gap_side", "gap_x", "gap_width"} }, 
    draw_check       = {"void"      , {"GtkStyle*", "cairo_t*", "GtkStateType", "GtkShadowType", "GtkWidget*", "const gchar*", "gint", "gint", "gint", "gint"}, {"style", "cr", "state_type", "shadow_type", "widget", "detail", "x", "y", "width", "height"} }, 
    draw_diamond     = {"void"      , {"GtkStyle*", "cairo_t*", "GtkStateType", "GtkShadowType", "GtkWidget*", "const gchar*", "gint", "gint", "gint", "gint"}, {"style", "cr", "state_type", "shadow_type", "widget", "detail", "x", "y", "width", "height"} }, 
    draw_expander    = {"void"      , {"GtkStyle*", "cairo_t*", "GtkStateType", "GtkWidget*", "const gchar*", "gint", "gint", "GtkExpanderStyle"}, {"style", "cr", "state_type", "widget", "detail", "x", "y", "expander_style"} }, 
    draw_extension   = {"void"      , {"GtkStyle*", "cairo_t*", "GtkStateType", "GtkShadowType", "GtkWidget*", "const gchar*", "gint", "gint", "gint", "gint", "GtkPositionType"}, {"style", "cr", "state_type", "shadow_type", "widget", "detail", "x", "y", "width", "height", "gap_side"} }, 
    draw_flat_box    = {"void"      , {"GtkStyle*", "cairo_t*", "GtkStateType", "GtkShadowType", "GtkWidget*", "const gchar*", "gint", "gint", "gint", "gint"}, {"style", "cr", "state_type", "shadow_type", "widget", "detail", "x", "y", "width", "height"} }, 
    draw_focus       = {"void"      , {"GtkStyle*", "cairo_t*", "GtkStateType", "GtkWidget*", "const gchar*", "gint", "gint", "gint", "gint"}, {"style", "cr", "state_type", "widget", "detail", "x", "y", "width", "height"} }, 
    draw_handle      = {"void"      , {"GtkStyle*", "cairo_t*", "GtkStateType", "GtkShadowType", "GtkWidget*", "const gchar*", "gint", "gint", "gint", "gint", "GtkOrientation"}, {"style", "cr", "state_type", "shadow_type", "widget", "detail", "x", "y", "width", "height", "orientation"} }, 
    draw_hline       = {"void"      , {"GtkStyle*", "cairo_t*", "GtkStateType", "GtkWidget*", "const gchar*", "gint", "gint", "gint"}, {"style", "cr", "state_type", "widget", "detail", "x1", "x2", "y"} }, 
    draw_layout      = {"void"      , {"GtkStyle*", "cairo_t*", "GtkStateType", "gboolean", "GtkWidget*", "const gchar*", "gint", "gint", "PangoLayout*"}, {"style", "cr", "state_type", "use_text", "widget", "detail", "x", "y", "layout"} }, 
    draw_option      = {"void"      , {"GtkStyle*", "cairo_t*", "GtkStateType", "GtkShadowType", "GtkWidget*", "const gchar*", "gint", "gint", "gint", "gint"}, {"style", "cr", "state_type", "shadow_type", "widget", "detail", "x", "y", "width", "height"} }, 
    draw_resize_grip = {"void"      , {"GtkStyle*", "cairo_t*", "GtkStateType", "GtkWidget*", "const gchar*", "GdkWindowEdge", "gint", "gint", "gint", "gint"}, {"style", "cr", "state_type", "widget", "detail", "edge", "x", "y", "width", "height"} }, 
    draw_shadow      = {"void"      , {"GtkStyle*", "cairo_t*", "GtkStateType", "GtkShadowType", "GtkWidget*", "const gchar*", "gint", "gint", "gint", "gint"}, {"style", "cr", "state_type", "shadow_type", "widget", "detail", "x", "y", "width", "height"} }, 
    draw_shadow_gap  = {"void"      , {"GtkStyle*", "cairo_t*", "GtkStateType", "GtkShadowType", "GtkWidget*", "const gchar*", "gint", "gint", "gint", "gint", "GtkPositionType", "gint", "gint"}, {"style", "cr", "state_type", "shadow_type", "widget", "detail", "x", "y", "width", "height", "gap_side", "gap_x", "gap_width"} }, 
    draw_slider      = {"void"      , {"GtkStyle*", "cairo_t*", "GtkStateType", "GtkShadowType", "GtkWidget*", "const gchar*", "gint", "gint", "gint", "gint", "GtkOrientation"}, {"style", "cr", "state_type", "shadow_type", "widget", "detail", "x", "y", "width", "height", "orientation"} }, 
    draw_spinner     = {"void"      , {"GtkStyle*", "cairo_t*", "GtkStateType", "GtkWidget*", "const gchar*", "guint", "gint", "gint", "gint", "gint"}, {"style", "cr", "state_type", "widget", "detail", "step", "x", "y", "width", "height"} }, 
    draw_tab         = {"void"      , {"GtkStyle*", "cairo_t*", "GtkStateType", "GtkShadowType", "GtkWidget*", "const gchar*", "gint", "gint", "gint", "gint"}, {"style", "cr", "state_type", "shadow_type", "widget", "detail", "x", "y", "width", "height"} }, 
    draw_vline       = {"void"      , {"GtkStyle*", "cairo_t*", "GtkStateType", "GtkWidget*", "const gchar*", "gint", "gint", "gint"}, {"style", "cr", "state_type", "widget", "detail", "y1_", "y2_", "x"} }, 
    init_from_rc     = {"void"      , {"GtkStyle*", "GtkRcStyle*"}, {"style", "rc_style"} }, 
    realize          = {"void"      , {"GtkStyle*"}, {"style"} }, 
    render_icon      = {"GdkPixbuf*", {"GtkStyle*", "const GtkIconSource*", "GtkTextDirection", "GtkStateType", "GtkIconSize", "GtkWidget*", "const gchar*"}, {"style", "source", "direction", "state", "size", "widget", "detail"} }, 
    set_background   = {"void"      , {"GtkStyle*", "GdkWindow*", "GtkStateType"}, {"style", "window", "state_type"} }, 
    unrealize        = {"void"      , {"GtkStyle*"}, {"style"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    realize   = {ret_type = "void", params = {type = {"GtkStyle*"}, name ={"style"}} }, 
    unrealize = {ret_type = "void", params = {type = {"GtkStyle*"}, name ={"style"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    context = {__type__="GtkStyleContext*" ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkStyleContext
Gtk324.GtkStyleContext = {
  class = "GtkStyleContext", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_style_context_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    changed = {"void", {"GtkStyleContext*"}, {"context"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed = {ret_type = "void", params = {type = {"GtkStyleContext*"}, name ={"context"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    direction       = {__type__="GtkTextDirection" ,__default__ = "GTK_TEXT_DIR_LTR" , __gencode__ = {"gtk_style_context_set_direction((GtkStyleContext*)({* id *}), (GtkTextDirection)({* property.value *}))"} },
    ["paint-clock"] = {__type__="GdkFrameClock*"                                     ,rwflags="rw" },
    parent          = {__type__="GtkStyleContext*"                                   , __gencode__ = {"gtk_style_context_set_parent((GtkStyleContext*)({* id *}), (GtkStyleContext*)({* property.value *}))"} },
    screen          = {__type__="GdkScreen*"                                         , __gencode__ = {"gtk_style_context_set_screen((GtkStyleContext*)({* id *}), (GdkScreen*)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkStyleProperties
Gtk324.GtkStyleProperties = {
  class = "GtkStyleProperties", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_style_properties_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
  implement = {Gtk324.GtkStyleProvider}, 
};

---------------------  GtkTextBuffer
Gtk324.GtkTextBuffer = {
  class = "GtkTextBuffer", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_text_buffer_new((GtkTextTagTable*)({* this.table.value *}))", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    apply_tag           = {"void", {"GtkTextBuffer*", "GtkTextTag*", "const GtkTextIter*", "const GtkTextIter*"}, {"buffer", "tag", "start", "end"} }, 
    begin_user_action   = {"void", {"GtkTextBuffer*"}, {"buffer"} }, 
    changed             = {"void", {"GtkTextBuffer*"}, {"buffer"} }, 
    delete_range        = {"void", {"GtkTextBuffer*", "GtkTextIter*", "GtkTextIter*"}, {"buffer", "start", "end"} }, 
    end_user_action     = {"void", {"GtkTextBuffer*"}, {"buffer"} }, 
    insert_child_anchor = {"void", {"GtkTextBuffer*", "GtkTextIter*", "GtkTextChildAnchor*"}, {"buffer", "iter", "anchor"} }, 
    insert_pixbuf       = {"void", {"GtkTextBuffer*", "GtkTextIter*", "GdkPixbuf*"}, {"buffer", "iter", "pixbuf"} }, 
    insert_text         = {"void", {"GtkTextBuffer*", "GtkTextIter*", "const gchar*", "gint"}, {"buffer", "pos", "new_text", "new_text_length"} }, 
    mark_deleted        = {"void", {"GtkTextBuffer*", "GtkTextMark*"}, {"buffer", "mark"} }, 
    mark_set            = {"void", {"GtkTextBuffer*", "const GtkTextIter*", "GtkTextMark*"}, {"buffer", "location", "mark"} }, 
    modified_changed    = {"void", {"GtkTextBuffer*"}, {"buffer"} }, 
    paste_done          = {"void", {"GtkTextBuffer*", "GtkClipboard*"}, {"buffer", "clipboard"} }, 
    remove_tag          = {"void", {"GtkTextBuffer*", "GtkTextTag*", "const GtkTextIter*", "const GtkTextIter*"}, {"buffer", "tag", "start", "end"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['apply-tag']           = {ret_type = "void", params = {type = {"GtkTextBuffer*", "GtkTextTag*", "GtkTextIter*", "GtkTextIter*"}, name ={"textbuffer", "tag", "start", "end"}} }, 
    ['begin-user-action']   = {ret_type = "void", params = {type = {"GtkTextBuffer*"}, name ={"textbuffer"}} }, 
    changed                 = {ret_type = "void", params = {type = {"GtkTextBuffer*"}, name ={"buffer"}} }, 
    ['delete-range']        = {ret_type = "void", params = {type = {"GtkTextBuffer*", "GtkTextIter*", "GtkTextIter*"}, name ={"textbuffer", "start", "end"}} }, 
    ['end-user-action']     = {ret_type = "void", params = {type = {"GtkTextBuffer*"}, name ={"textbuffer"}} }, 
    ['insert-child-anchor'] = {ret_type = "void", params = {type = {"GtkTextBuffer*", "GtkTextIter*", "GtkTextChildAnchor*"}, name ={"textbuffer", "location", "anchor"}} }, 
    ['insert-pixbuf']       = {ret_type = "void", params = {type = {"GtkTextBuffer*", "GtkTextIter*", "GdkPixbuf*"}, name ={"textbuffer", "location", "pixbuf"}} }, 
    ['insert-text']         = {ret_type = "void", params = {type = {"GtkTextBuffer*", "GtkTextIter*", "gchar*", "gint"}, name ={"textbuffer", "location", "text", "len"}} }, 
    ['mark-deleted']        = {ret_type = "void", params = {type = {"GtkTextBuffer*", "GtkTextMark*"}, name ={"textbuffer", "mark"}} }, 
    ['mark-set']            = {ret_type = "void", params = {type = {"GtkTextBuffer*", "GtkTextIter*", "GtkTextMark*"}, name ={"textbuffer", "location", "mark"}} }, 
    ['modified-changed']    = {ret_type = "void", params = {type = {"GtkTextBuffer*"}, name ={"textbuffer"}} }, 
    ['paste-done']          = {ret_type = "void", params = {type = {"GtkTextBuffer*", "GtkClipboard*"}, name ={"textbuffer", "clipboard"}} }, 
    ['remove-tag']          = {ret_type = "void", params = {type = {"GtkTextBuffer*", "GtkTextTag*", "GtkTextIter*", "GtkTextIter*"}, name ={"textbuffer", "tag", "start", "end"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["copy-target-list"]  = {__type__="GtkTargetList*"                           },
    ["cursor-position"]   = {__type__="gint"             ,__default__ = "0"      },
    ["has-selection"]     = {__type__="gboolean"         ,__default__ = "FALSE"  },
    ["paste-target-list"] = {__type__="GtkTargetList*"                           },
    ["tag-table"]         = {__type__="GtkTextTagTable*"                        ,rwflags="rw" },
    text                  = {__type__="gchar*"           ,__default__ = "\"\""  , __gencode__ = {"gtk_text_buffer_set_text((GtkTextBuffer*)({* id *}), (const gchar*)({* property.value *}), (gint)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkTextChildAnchor
Gtk324.GtkTextChildAnchor = {
  class = "GtkTextChildAnchor", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_text_child_anchor_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkTextMark
Gtk324.GtkTextMark = {
  class = "GtkTextMark", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_text_mark_new((const gchar*)({* this.name.value *}), (gboolean)({* this['left-gravity'].value *}))", 
            params = { type = {"const gchar*", "gboolean"}, 
                       name = {"name", "left-gravity"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["left-gravity"] = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
    name             = {__type__="gchar*"   ,__default__ = "NULL"  ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkTextTag
Gtk324.GtkTextTag = {
  class = "GtkTextTag", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_text_tag_new((const gchar*)({* this.name.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"name"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    event = {"gboolean", {"GtkTextTag*", "GObject*", "GdkEvent*", "const GtkTextIter*"}, {"tag", "event_object", "event", "iter"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    event = {ret_type = "gboolean", params = {type = {"GtkTextTag*", "GObject*", "GdkEvent*", "const GtkTextIter*"}, name ={"tag", "event_object", "event", "iter"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["accumulative-margin"]        = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    background                     = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="w" },
    ["background-full-height"]     = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    ["background-full-height-set"] = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    ["background-gdk"]             = {__type__="GdkColor*"                                                   ,rwflags="rw" },
    ["background-rgba"]            = {__type__="GdkRGBA*"                                                    ,rwflags="rw" },
    ["background-set"]             = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    direction                      = {__type__="GtkTextDirection"      ,__default__ = "GTK_TEXT_DIR_NONE"    ,rwflags="rw" },
    editable                       = {__type__="gboolean"              ,__default__ = "TRUE"                 ,rwflags="rw" },
    ["editable-set"]               = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    fallback                       = {__type__="gboolean"              ,__default__ = "TRUE"                 ,rwflags="rw" },
    ["fallback-set"]               = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    family                         = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="rw" },
    ["family-set"]                 = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    font                           = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="rw" },
    ["font-desc"]                  = {__type__="PangoFontDescription*"                                       ,rwflags="rw" },
    ["font-features"]              = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="rw" },
    ["font-features-set"]          = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    foreground                     = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="w" },
    ["foreground-gdk"]             = {__type__="GdkColor*"                                                   ,rwflags="rw" },
    ["foreground-rgba"]            = {__type__="GdkRGBA*"                                                    ,rwflags="rw" },
    ["foreground-set"]             = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    indent                         = {__type__="gint"                  ,__default__ = "0"                    ,rwflags="rw" },
    ["indent-set"]                 = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    invisible                      = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    ["invisible-set"]              = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    justification                  = {__type__="GtkJustification"      ,__default__ = "GTK_JUSTIFY_LEFT"     ,rwflags="rw" },
    ["justification-set"]          = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    language                       = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="rw" },
    ["language-set"]               = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    ["left-margin"]                = {__type__="gint"                  ,__default__ = "0"                    ,rwflags="rw" },
    ["left-margin-set"]            = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    ["letter-spacing"]             = {__type__="gint"                  ,__default__ = "0"                    ,rwflags="rw" },
    ["letter-spacing-set"]         = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    name                           = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="rw" },
    ["paragraph-background"]       = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="w" },
    ["paragraph-background-gdk"]   = {__type__="GdkColor*"                                                   ,rwflags="rw" },
    ["paragraph-background-rgba"]  = {__type__="GdkRGBA*"                                                    ,rwflags="rw" },
    ["paragraph-background-set"]   = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    ["pixels-above-lines"]         = {__type__="gint"                  ,__default__ = "0"                    ,rwflags="rw" },
    ["pixels-above-lines-set"]     = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    ["pixels-below-lines"]         = {__type__="gint"                  ,__default__ = "0"                    ,rwflags="rw" },
    ["pixels-below-lines-set"]     = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    ["pixels-inside-wrap"]         = {__type__="gint"                  ,__default__ = "0"                    ,rwflags="rw" },
    ["pixels-inside-wrap-set"]     = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    ["right-margin"]               = {__type__="gint"                  ,__default__ = "0"                    ,rwflags="rw" },
    ["right-margin-set"]           = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    rise                           = {__type__="gint"                  ,__default__ = "0"                    ,rwflags="rw" },
    ["rise-set"]                   = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    scale                          = {__type__="gdouble"               ,__default__ = "1"                    ,rwflags="rw" },
    ["scale-set"]                  = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    size                           = {__type__="gint"                  ,__default__ = "0"                    ,rwflags="rw" },
    ["size-points"]                = {__type__="gdouble"               ,__default__ = "0"                    ,rwflags="rw" },
    ["size-set"]                   = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    stretch                        = {__type__="PangoStretch"          ,__default__ = "PANGO_STRETCH_NORMAL" ,rwflags="rw" },
    ["stretch-set"]                = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    strikethrough                  = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    ["strikethrough-rgba"]         = {__type__="GdkRGBA*"                                                    ,rwflags="rw" },
    ["strikethrough-rgba-set"]     = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    ["strikethrough-set"]          = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    style                          = {__type__="PangoStyle"            ,__default__ = "PANGO_STYLE_NORMAL"   ,rwflags="rw" },
    ["style-set"]                  = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    tabs                           = {__type__="PangoTabArray*"                                              ,rwflags="rw" },
    ["tabs-set"]                   = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    underline                      = {__type__="PangoUnderline"        ,__default__ = "PANGO_UNDERLINE_NONE" ,rwflags="rw" },
    ["underline-rgba"]             = {__type__="GdkRGBA*"                                                    ,rwflags="rw" },
    ["underline-rgba-set"]         = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    ["underline-set"]              = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    variant                        = {__type__="PangoVariant"          ,__default__ = "PANGO_VARIANT_NORMAL" ,rwflags="rw" },
    ["variant-set"]                = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    weight                         = {__type__="gint"                  ,__default__ = "400"                  ,rwflags="rw" },
    ["weight-set"]                 = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    ["wrap-mode"]                  = {__type__="GtkWrapMode"           ,__default__ = "GTK_WRAP_NONE"        ,rwflags="rw" },
    ["wrap-mode-set"]              = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkTextTagTable
Gtk324.GtkTextTagTable = {
  class = "GtkTextTagTable", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_text_tag_table_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    tag_added   = {"void", {"GtkTextTagTable*", "GtkTextTag*"}, {"table", "tag"} }, 
    tag_changed = {"void", {"GtkTextTagTable*", "GtkTextTag*", "gboolean"}, {"table", "tag", "size_changed"} }, 
    tag_removed = {"void", {"GtkTextTagTable*", "GtkTextTag*"}, {"table", "tag"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['tag-added']   = {ret_type = "void", params = {type = {"GtkTextTagTable*", "GtkTextTag*"}, name ={"texttagtable", "tag"}} }, 
    ['tag-changed'] = {ret_type = "void", params = {type = {"GtkTextTagTable*", "GtkTextTag*", "gboolean"}, name ={"texttagtable", "tag", "size_changed"}} }, 
    ['tag-removed'] = {ret_type = "void", params = {type = {"GtkTextTagTable*", "GtkTextTag*"}, name ={"texttagtable", "tag"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkThemingEngine
Gtk324.GtkThemingEngine = {
  class = "GtkThemingEngine", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    render_activity     = {"void"      , {"GtkThemingEngine*", "cairo_t*", "gdouble", "gdouble", "gdouble", "gdouble"}, {"engine", "cr", "x", "y", "width", "height"} }, 
    render_arrow        = {"void"      , {"GtkThemingEngine*", "cairo_t*", "gdouble", "gdouble", "gdouble", "gdouble"}, {"engine", "cr", "angle", "x", "y", "size"} }, 
    render_background   = {"void"      , {"GtkThemingEngine*", "cairo_t*", "gdouble", "gdouble", "gdouble", "gdouble"}, {"engine", "cr", "x", "y", "width", "height"} }, 
    render_check        = {"void"      , {"GtkThemingEngine*", "cairo_t*", "gdouble", "gdouble", "gdouble", "gdouble"}, {"engine", "cr", "x", "y", "width", "height"} }, 
    render_expander     = {"void"      , {"GtkThemingEngine*", "cairo_t*", "gdouble", "gdouble", "gdouble", "gdouble"}, {"engine", "cr", "x", "y", "width", "height"} }, 
    render_extension    = {"void"      , {"GtkThemingEngine*", "cairo_t*", "gdouble", "gdouble", "gdouble", "gdouble", "GtkPositionType"}, {"engine", "cr", "x", "y", "width", "height", "gap_side"} }, 
    render_focus        = {"void"      , {"GtkThemingEngine*", "cairo_t*", "gdouble", "gdouble", "gdouble", "gdouble"}, {"engine", "cr", "x", "y", "width", "height"} }, 
    render_frame        = {"void"      , {"GtkThemingEngine*", "cairo_t*", "gdouble", "gdouble", "gdouble", "gdouble"}, {"engine", "cr", "x", "y", "width", "height"} }, 
    render_frame_gap    = {"void"      , {"GtkThemingEngine*", "cairo_t*", "gdouble", "gdouble", "gdouble", "gdouble", "GtkPositionType", "gdouble", "gdouble"}, {"engine", "cr", "x", "y", "width", "height", "gap_side", "xy0_gap", "xy1_gap"} }, 
    render_handle       = {"void"      , {"GtkThemingEngine*", "cairo_t*", "gdouble", "gdouble", "gdouble", "gdouble"}, {"engine", "cr", "x", "y", "width", "height"} }, 
    render_icon         = {"void"      , {"GtkThemingEngine*", "cairo_t*", "GdkPixbuf*", "gdouble", "gdouble"}, {"engine", "cr", "pixbuf", "x", "y"} }, 
    render_icon_pixbuf  = {"GdkPixbuf*", {"GtkThemingEngine*", "const GtkIconSource*", "GtkIconSize"}, {"engine", "source", "size"} }, 
    render_icon_surface = {"void"      , {"GtkThemingEngine*", "cairo_t*", "cairo_surface_t*", "gdouble", "gdouble"}, {"engine", "cr", "surface", "x", "y"} }, 
    render_layout       = {"void"      , {"GtkThemingEngine*", "cairo_t*", "gdouble", "gdouble", "PangoLayout*"}, {"engine", "cr", "x", "y", "layout"} }, 
    render_line         = {"void"      , {"GtkThemingEngine*", "cairo_t*", "gdouble", "gdouble", "gdouble", "gdouble"}, {"engine", "cr", "x0", "y0", "x1", "y1"} }, 
    render_option       = {"void"      , {"GtkThemingEngine*", "cairo_t*", "gdouble", "gdouble", "gdouble", "gdouble"}, {"engine", "cr", "x", "y", "width", "height"} }, 
    render_slider       = {"void"      , {"GtkThemingEngine*", "cairo_t*", "gdouble", "gdouble", "gdouble", "gdouble", "GtkOrientation"}, {"engine", "cr", "x", "y", "width", "height", "orientation"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    name = {__type__="gchar*" ,__default__ = "NULL" ,rwflags="rw" },
  },
  parent = nil, 
};

---------------------  GtkTooltip
Gtk324.GtkTooltip = {
  class = "GtkTooltip", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkToplevelAccessible
Gtk324.GtkToplevelAccessible = {
  class = "GtkToplevelAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkTreeModelFilter
Gtk324.GtkTreeModelFilter = {
  class = "GtkTreeModelFilter", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    modify  = {"void"    , {"GtkTreeModelFilter*", "GtkTreeModel*", "GtkTreeIter*", "GValue*", "gint"}, {"self", "child_model", "iter", "value", "column"} }, 
    visible = {"gboolean", {"GtkTreeModelFilter*", "GtkTreeModel*", "GtkTreeIter*"}, {"self", "child_model", "iter"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["child-model"]  = {__type__="GtkTreeModel*" ,rwflags="rw" },
    ["virtual-root"] = {__type__="GtkTreePath*"  ,rwflags="rw" },
  },
  parent = nil, 
  implement = {Gtk324.GtkTreeDragSource, Gtk324.GtkTreeModel}, 
};

---------------------  GtkTreeModelSort
Gtk324.GtkTreeModelSort = {
  class = "GtkTreeModelSort", 
  constructor = { 
    -- 名称[- ==> _], 
    new_with_model = { gencode = "gtk_tree_model_sort_new_with_model((GtkTreeModel*)({* this.child_model.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    model = {__type__="GtkTreeModel*" ,rwflags="rw" },
  },
  parent = nil, 
  implement = {Gtk324.GtkTreeDragSource, Gtk324.GtkTreeModel, Gtk324.GtkTreeSortable}, 
};

---------------------  GtkTreeSelection
Gtk324.GtkTreeSelection = {
  class = "GtkTreeSelection", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    changed = {"void", {"GtkTreeSelection*"}, {"selection"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed = {ret_type = "void", params = {type = {"GtkTreeSelection*"}, name ={"selection"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    mode = {__type__="GtkSelectionMode" ,__default__ = "GTK_SELECTION_SINGLE" , __gencode__ = {"gtk_tree_selection_set_mode((GtkTreeSelection*)({* id *}), (GtkSelectionMode)({* property.value *}))"} },
  },
  parent = nil, 
};

---------------------  GtkTreeStore
Gtk324.GtkTreeStore = {
  class = "GtkTreeStore", 
  constructor = { 
    -- 名称[- ==> _], 
    new  = { gencode = "gtk_tree_store_new((gint)({* this.n_columns.value *}), 0)", 
            params = { type = {}, name = {} } },
    newv = { gencode = "gtk_tree_store_newv((gint)({* this.n_columns.value *}), (GType*)({* this.types.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
  implement = {Gtk324.GtkBuildable, Gtk324.GtkTreeDragDest, Gtk324.GtkTreeDragSource, Gtk324.GtkTreeModel, Gtk324.GtkTreeSortable}, 
};

---------------------  GtkTreeViewColumn
Gtk324.GtkTreeViewColumn = {
  class = "GtkTreeViewColumn", 
  constructor = { 
    -- 名称[- ==> _], 
    new                 = { gencode = "gtk_tree_view_column_new()", 
            params = { type = {}, name = {} } },
    new_with_area       = { gencode = "gtk_tree_view_column_new_with_area((GtkCellArea*)({* this.area.value *}))", 
            params = { type = {}, name = {} } },
    new_with_attributes = { gencode = "gtk_tree_view_column_new_with_attributes((const gchar*)({* this.title.value *}), (GtkCellRenderer*)({* this.cell.value *}), 0)", 
            params = { type = {"const gchar*"}, 
                       name = {"title"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    clicked = {"void", {"GtkTreeViewColumn*"}, {"tree_column"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    clicked = {ret_type = "void", params = {type = {"GtkTreeViewColumn*"}, name ={"tree_column"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    alignment          = {__type__="gfloat"                  ,__default__ = "0"                              , __gencode__ = {"gtk_tree_view_column_set_alignment((GtkTreeViewColumn*)({* id *}), (gfloat)({* property.value *}))"} },
    ["cell-area"]      = {__type__="GtkCellArea*"                                                            ,rwflags="rw" },
    clickable          = {__type__="gboolean"                ,__default__ = "FALSE"                          , __gencode__ = {"gtk_tree_view_column_set_clickable((GtkTreeViewColumn*)({* id *}), (gboolean)({* property.value *}))"} },
    expand             = {__type__="gboolean"                ,__default__ = "FALSE"                          , __gencode__ = {"gtk_tree_view_column_set_expand((GtkTreeViewColumn*)({* id *}), (gboolean)({* property.value *}))"} },
    ["fixed-width"]    = {__type__="gint"                    ,__default__ = "-1"                             , __gencode__ = {"gtk_tree_view_column_set_fixed_width((GtkTreeViewColumn*)({* id *}), (gint)({* property.value *}))"} },
    ["max-width"]      = {__type__="gint"                    ,__default__ = "-1"                             , __gencode__ = {"gtk_tree_view_column_set_max_width((GtkTreeViewColumn*)({* id *}), (gint)({* property.value *}))"} },
    ["min-width"]      = {__type__="gint"                    ,__default__ = "-1"                             , __gencode__ = {"gtk_tree_view_column_set_min_width((GtkTreeViewColumn*)({* id *}), (gint)({* property.value *}))"} },
    reorderable        = {__type__="gboolean"                ,__default__ = "FALSE"                          , __gencode__ = {"gtk_tree_view_column_set_reorderable((GtkTreeViewColumn*)({* id *}), (gboolean)({* property.value *}))"} },
    resizable          = {__type__="gboolean"                ,__default__ = "FALSE"                          , __gencode__ = {"gtk_tree_view_column_set_resizable((GtkTreeViewColumn*)({* id *}), (gboolean)({* property.value *}))"} },
    sizing             = {__type__="GtkTreeViewColumnSizing" ,__default__ = "GTK_TREE_VIEW_COLUMN_GROW_ONLY" , __gencode__ = {"gtk_tree_view_column_set_sizing((GtkTreeViewColumn*)({* id *}), (GtkTreeViewColumnSizing)({* property.value *}))"} },
    ["sort-column-id"] = {__type__="gint"                    ,__default__ = "-1"                             , __gencode__ = {"gtk_tree_view_column_set_sort_column_id((GtkTreeViewColumn*)({* id *}), (gint)({* property.value *}))"} },
    ["sort-indicator"] = {__type__="gboolean"                ,__default__ = "FALSE"                          , __gencode__ = {"gtk_tree_view_column_set_sort_indicator((GtkTreeViewColumn*)({* id *}), (gboolean)({* property.value *}))"} },
    ["sort-order"]     = {__type__="GtkSortType"             ,__default__ = "GTK_SORT_ASCENDING"             , __gencode__ = {"gtk_tree_view_column_set_sort_order((GtkTreeViewColumn*)({* id *}), (GtkSortType)({* property.value *}))"} },
    spacing            = {__type__="gint"                    ,__default__ = "0"                              , __gencode__ = {"gtk_tree_view_column_set_spacing((GtkTreeViewColumn*)({* id *}), (gint)({* property.value *}))"} },
    title              = {__type__="gchar*"                  ,__default__ = "\"\""                           , __gencode__ = {"gtk_tree_view_column_set_title((GtkTreeViewColumn*)({* id *}), (const gchar*)({* property.value *}))"} },
    visible            = {__type__="gboolean"                ,__default__ = "TRUE"                           , __gencode__ = {"gtk_tree_view_column_set_visible((GtkTreeViewColumn*)({* id *}), (gboolean)({* property.value *}))"} },
    widget             = {__type__="GtkWidget*"                                                              , __gencode__ = {"gtk_tree_view_column_set_widget((GtkTreeViewColumn*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    width              = {__type__="gint"                    ,__default__ = "0"                               },
    ["x-offset"]       = {__type__="gint"                    ,__default__ = "0"                               },
  },
  parent = nil, 
  implement = {Gtk324.GtkBuildable, Gtk324.GtkCellLayout}, 
};

---------------------  GtkUIManager
Gtk324.GtkUIManager = {
  class = "GtkUIManager", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_ui_manager_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    actions_changed  = {"void"      , {"GtkUIManager*"}, {"manager"} }, 
    add_widget       = {"void"      , {"GtkUIManager*", "GtkWidget*"}, {"manager", "widget"} }, 
    connect_proxy    = {"void"      , {"GtkUIManager*", "GtkAction*", "GtkWidget*"}, {"manager", "action", "proxy"} }, 
    disconnect_proxy = {"void"      , {"GtkUIManager*", "GtkAction*", "GtkWidget*"}, {"manager", "action", "proxy"} }, 
    get_action       = {"GtkAction*", {"GtkUIManager*", "const gchar*"}, {"manager", "path"} }, 
    get_widget       = {"GtkWidget*", {"GtkUIManager*", "const gchar*"}, {"manager", "path"} }, 
    post_activate    = {"void"      , {"GtkUIManager*", "GtkAction*"}, {"manager", "action"} }, 
    pre_activate     = {"void"      , {"GtkUIManager*", "GtkAction*"}, {"manager", "action"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['actions-changed']  = {ret_type = "void", params = {type = {"GtkUIManager*"}, name ={"uimanager"}} }, 
    ['add-widget']       = {ret_type = "void", params = {type = {"GtkUIManager*", "GtkWidget*"}, name ={"uimanager", "widget"}} }, 
    ['connect-proxy']    = {ret_type = "void", params = {type = {"GtkUIManager*", "GtkAction*", "GtkWidget*"}, name ={"uimanager", "action", "proxy"}} }, 
    ['disconnect-proxy'] = {ret_type = "void", params = {type = {"GtkUIManager*", "GtkAction*", "GtkWidget*"}, name ={"uimanager", "action", "proxy"}} }, 
    ['post-activate']    = {ret_type = "void", params = {type = {"GtkUIManager*", "GtkAction*"}, name ={"uimanager", "action"}} }, 
    ['pre-activate']     = {ret_type = "void", params = {type = {"GtkUIManager*", "GtkAction*"}, name ={"uimanager", "action"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["add-tearoffs"] = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_ui_manager_set_add_tearoffs((GtkUIManager*)({* id *}), (gboolean)({* property.value *}))"} },
    ui               = {__type__="gchar*"   ,__default__ = "\""     },
  },
  parent = nil, 
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkWidget
Gtk324.GtkWidget = {
  class = "GtkWidget", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_widget_new((GType)({* this.type.value *}), (const gchar*)({* this.first_property_name.value *}), 0)", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    adjust_baseline_allocation                  = {"void"              , {"GtkWidget*", "gint*"}, {"widget", "baseline"} }, 
    adjust_baseline_request                     = {"void"              , {"GtkWidget*", "gint*", "gint*"}, {"widget", "minimum_baseline", "natural_baseline"} }, 
    adjust_size_allocation                      = {"void"              , {"GtkWidget*", "GtkOrientation", "gint*", "gint*", "gint*", "gint*"}, {"widget", "orientation", "minimum_size", "natural_size", "allocated_pos", "allocated_size"} }, 
    adjust_size_request                         = {"void"              , {"GtkWidget*", "GtkOrientation", "gint*", "gint*"}, {"widget", "orientation", "minimum_size", "natural_size"} }, 
    button_press_event                          = {"gboolean"          , {"GtkWidget*", "GdkEventButton*"}, {"widget", "event"} }, 
    button_release_event                        = {"gboolean"          , {"GtkWidget*", "GdkEventButton*"}, {"widget", "event"} }, 
    can_activate_accel                          = {"gboolean"          , {"GtkWidget*", "guint"}, {"widget", "signal_id"} }, 
    child_notify                                = {"void"              , {"GtkWidget*", "GParamSpec*"}, {"widget", "child_property"} }, 
    composited_changed                          = {"void"              , {"GtkWidget*"}, {"widget"} }, 
    compute_expand                              = {"void"              , {"GtkWidget*", "gboolean*", "gboolean*"}, {"widget", "hexpand_p", "vexpand_p"} }, 
    configure_event                             = {"gboolean"          , {"GtkWidget*", "GdkEventConfigure*"}, {"widget", "event"} }, 
    damage_event                                = {"gboolean"          , {"GtkWidget*", "GdkEventExpose*"}, {"widget", "event"} }, 
    delete_event                                = {"gboolean"          , {"GtkWidget*", "GdkEventAny*"}, {"widget", "event"} }, 
    destroy                                     = {"void"              , {"GtkWidget*"}, {"widget"} }, 
    destroy_event                               = {"gboolean"          , {"GtkWidget*", "GdkEventAny*"}, {"widget", "event"} }, 
    direction_changed                           = {"void"              , {"GtkWidget*", "GtkTextDirection"}, {"widget", "previous_direction"} }, 
    dispatch_child_properties_changed           = {"void"              , {"GtkWidget*", "guint", "GParamSpec**"}, {"widget", "n_pspecs", "pspecs"} }, 
    drag_begin                                  = {"void"              , {"GtkWidget*", "GdkDragContext*"}, {"widget", "context"} }, 
    drag_data_delete                            = {"void"              , {"GtkWidget*", "GdkDragContext*"}, {"widget", "context"} }, 
    drag_data_get                               = {"void"              , {"GtkWidget*", "GdkDragContext*", "GtkSelectionData*", "guint", "guint"}, {"widget", "context", "selection_data", "info", "time_"} }, 
    drag_data_received                          = {"void"              , {"GtkWidget*", "GdkDragContext*", "gint", "gint", "GtkSelectionData*", "guint", "guint"}, {"widget", "context", "x", "y", "selection_data", "info", "time_"} }, 
    drag_drop                                   = {"gboolean"          , {"GtkWidget*", "GdkDragContext*", "gint", "gint", "guint"}, {"widget", "context", "x", "y", "time_"} }, 
    drag_end                                    = {"void"              , {"GtkWidget*", "GdkDragContext*"}, {"widget", "context"} }, 
    drag_failed                                 = {"gboolean"          , {"GtkWidget*", "GdkDragContext*", "GtkDragResult"}, {"widget", "context", "result"} }, 
    drag_leave                                  = {"void"              , {"GtkWidget*", "GdkDragContext*", "guint"}, {"widget", "context", "time_"} }, 
    drag_motion                                 = {"gboolean"          , {"GtkWidget*", "GdkDragContext*", "gint", "gint", "guint"}, {"widget", "context", "x", "y", "time_"} }, 
    draw                                        = {"gboolean"          , {"GtkWidget*", "cairo_t*"}, {"widget", "cr"} }, 
    enter_notify_event                          = {"gboolean"          , {"GtkWidget*", "GdkEventCrossing*"}, {"widget", "event"} }, 
    event                                       = {"gboolean"          , {"GtkWidget*", "GdkEvent*"}, {"widget", "event"} }, 
    focus                                       = {"gboolean"          , {"GtkWidget*", "GtkDirectionType"}, {"widget", "direction"} }, 
    focus_in_event                              = {"gboolean"          , {"GtkWidget*", "GdkEventFocus*"}, {"widget", "event"} }, 
    focus_out_event                             = {"gboolean"          , {"GtkWidget*", "GdkEventFocus*"}, {"widget", "event"} }, 
    get_accessible                              = {"AtkObject*"        , {"GtkWidget*"}, {"widget"} }, 
    get_preferred_height                        = {"void"              , {"GtkWidget*", "gint*", "gint*"}, {"widget", "minimum_height", "natural_height"} }, 
    get_preferred_height_and_baseline_for_width = {"void"              , {"GtkWidget*", "gint", "gint*", "gint*", "gint*", "gint*"}, {"widget", "width", "minimum_height", "natural_height", "minimum_baseline", "natural_baseline"} }, 
    get_preferred_height_for_width              = {"void"              , {"GtkWidget*", "gint", "gint*", "gint*"}, {"widget", "width", "minimum_height", "natural_height"} }, 
    get_preferred_width                         = {"void"              , {"GtkWidget*", "gint*", "gint*"}, {"widget", "minimum_width", "natural_width"} }, 
    get_preferred_width_for_height              = {"void"              , {"GtkWidget*", "gint", "gint*", "gint*"}, {"widget", "height", "minimum_width", "natural_width"} }, 
    get_request_mode                            = {"GtkSizeRequestMode", {"GtkWidget*"}, {"widget"} }, 
    grab_broken_event                           = {"gboolean"          , {"GtkWidget*", "GdkEventGrabBroken*"}, {"widget", "event"} }, 
    grab_focus                                  = {"void"              , {"GtkWidget*"}, {"widget"} }, 
    grab_notify                                 = {"void"              , {"GtkWidget*", "gboolean"}, {"widget", "was_grabbed"} }, 
    hide                                        = {"void"              , {"GtkWidget*"}, {"widget"} }, 
    hierarchy_changed                           = {"void"              , {"GtkWidget*", "GtkWidget*"}, {"widget", "previous_toplevel"} }, 
    key_press_event                             = {"gboolean"          , {"GtkWidget*", "GdkEventKey*"}, {"widget", "event"} }, 
    key_release_event                           = {"gboolean"          , {"GtkWidget*", "GdkEventKey*"}, {"widget", "event"} }, 
    keynav_failed                               = {"gboolean"          , {"GtkWidget*", "GtkDirectionType"}, {"widget", "direction"} }, 
    leave_notify_event                          = {"gboolean"          , {"GtkWidget*", "GdkEventCrossing*"}, {"widget", "event"} }, 
    map                                         = {"void"              , {"GtkWidget*"}, {"widget"} }, 
    map_event                                   = {"gboolean"          , {"GtkWidget*", "GdkEventAny*"}, {"widget", "event"} }, 
    mnemonic_activate                           = {"gboolean"          , {"GtkWidget*", "gboolean"}, {"widget", "group_cycling"} }, 
    motion_notify_event                         = {"gboolean"          , {"GtkWidget*", "GdkEventMotion*"}, {"widget", "event"} }, 
    move_focus                                  = {"void"              , {"GtkWidget*", "GtkDirectionType"}, {"widget", "direction"} }, 
    parent_set                                  = {"void"              , {"GtkWidget*", "GtkWidget*"}, {"widget", "previous_parent"} }, 
    popup_menu                                  = {"gboolean"          , {"GtkWidget*"}, {"widget"} }, 
    property_notify_event                       = {"gboolean"          , {"GtkWidget*", "GdkEventProperty*"}, {"widget", "event"} }, 
    proximity_in_event                          = {"gboolean"          , {"GtkWidget*", "GdkEventProximity*"}, {"widget", "event"} }, 
    proximity_out_event                         = {"gboolean"          , {"GtkWidget*", "GdkEventProximity*"}, {"widget", "event"} }, 
    query_tooltip                               = {"gboolean"          , {"GtkWidget*", "gint", "gint", "gboolean", "GtkTooltip*"}, {"widget", "x", "y", "keyboard_tooltip", "tooltip"} }, 
    queue_draw_region                           = {"void"              , {"GtkWidget*", "const cairo_region_t*"}, {"widget", "region"} }, 
    realize                                     = {"void"              , {"GtkWidget*"}, {"widget"} }, 
    screen_changed                              = {"void"              , {"GtkWidget*", "GdkScreen*"}, {"widget", "previous_screen"} }, 
    scroll_event                                = {"gboolean"          , {"GtkWidget*", "GdkEventScroll*"}, {"widget", "event"} }, 
    selection_clear_event                       = {"gboolean"          , {"GtkWidget*", "GdkEventSelection*"}, {"widget", "event"} }, 
    selection_get                               = {"void"              , {"GtkWidget*", "GtkSelectionData*", "guint", "guint"}, {"widget", "selection_data", "info", "time_"} }, 
    selection_notify_event                      = {"gboolean"          , {"GtkWidget*", "GdkEventSelection*"}, {"widget", "event"} }, 
    selection_received                          = {"void"              , {"GtkWidget*", "GtkSelectionData*", "guint"}, {"widget", "selection_data", "time_"} }, 
    selection_request_event                     = {"gboolean"          , {"GtkWidget*", "GdkEventSelection*"}, {"widget", "event"} }, 
    show                                        = {"void"              , {"GtkWidget*"}, {"widget"} }, 
    show_all                                    = {"void"              , {"GtkWidget*"}, {"widget"} }, 
    show_help                                   = {"gboolean"          , {"GtkWidget*", "GtkWidgetHelpType"}, {"widget", "help_type"} }, 
    size_allocate                               = {"void"              , {"GtkWidget*", "GtkAllocation*"}, {"widget", "allocation"} }, 
    state_changed                               = {"void"              , {"GtkWidget*", "GtkStateType"}, {"widget", "previous_state"} }, 
    state_flags_changed                         = {"void"              , {"GtkWidget*", "GtkStateFlags"}, {"widget", "previous_state_flags"} }, 
    style_set                                   = {"void"              , {"GtkWidget*", "GtkStyle*"}, {"widget", "previous_style"} }, 
    style_updated                               = {"void"              , {"GtkWidget*"}, {"widget"} }, 
    touch_event                                 = {"gboolean"          , {"GtkWidget*", "GdkEventTouch*"}, {"widget", "event"} }, 
    unmap                                       = {"void"              , {"GtkWidget*"}, {"widget"} }, 
    unmap_event                                 = {"gboolean"          , {"GtkWidget*", "GdkEventAny*"}, {"widget", "event"} }, 
    unrealize                                   = {"void"              , {"GtkWidget*"}, {"widget"} }, 
    visibility_notify_event                     = {"gboolean"          , {"GtkWidget*", "GdkEventVisibility*"}, {"widget", "event"} }, 
    window_state_event                          = {"gboolean"          , {"GtkWidget*", "GdkEventWindowState*"}, {"widget", "event"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['accel-closures-changed']  = {ret_type = "void"    , params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    ['button-press-event']      = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventButton*"}, name ={"widget", "event"}} }, 
    ['button-release-event']    = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventButton*"}, name ={"widget", "event"}} }, 
    ['can-activate-accel']      = {ret_type = "gboolean", params = {type = {"GtkWidget*", "guint"}, name ={"widget", "signal_id"}} }, 
    ['child-notify']            = {ret_type = "void"    , params = {type = {"GtkWidget*", "GParamSpec*"}, name ={"widget", "child_property"}} }, 
    ['composited-changed']      = {ret_type = "void"    , params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    ['configure-event']         = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventConfigure*"}, name ={"widget", "event"}} }, 
    ['damage-event']            = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventExpose*"}, name ={"widget", "event"}} }, 
    ['delete-event']            = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEvent*"}, name ={"widget", "event"}} }, 
    destroy                     = {ret_type = "void"    , params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    ['destroy-event']           = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEvent*"}, name ={"widget", "event"}} }, 
    ['direction-changed']       = {ret_type = "void"    , params = {type = {"GtkWidget*", "GtkTextDirection"}, name ={"widget", "previous_direction"}} }, 
    ['drag-begin']              = {ret_type = "void"    , params = {type = {"GtkWidget*", "GdkDragContext*"}, name ={"widget", "context"}} }, 
    ['drag-data-delete']        = {ret_type = "void"    , params = {type = {"GtkWidget*", "GdkDragContext*"}, name ={"widget", "context"}} }, 
    ['drag-data-get']           = {ret_type = "void"    , params = {type = {"GtkWidget*", "GdkDragContext*", "GtkSelectionData*", "guint", "guint"}, name ={"widget", "context", "data", "info", "time"}} }, 
    ['drag-data-received']      = {ret_type = "void"    , params = {type = {"GtkWidget*", "GdkDragContext*", "gint", "gint", "GtkSelectionData*", "guint", "guint"}, name ={"widget", "context", "x", "y", "data", "info", "time"}} }, 
    ['drag-drop']               = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkDragContext*", "gint", "gint", "guint"}, name ={"widget", "context", "x", "y", "time"}} }, 
    ['drag-end']                = {ret_type = "void"    , params = {type = {"GtkWidget*", "GdkDragContext*"}, name ={"widget", "context"}} }, 
    ['drag-failed']             = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkDragContext*", "GtkDragResult"}, name ={"widget", "context", "result"}} }, 
    ['drag-leave']              = {ret_type = "void"    , params = {type = {"GtkWidget*", "GdkDragContext*", "guint"}, name ={"widget", "context", "time"}} }, 
    ['drag-motion']             = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkDragContext*", "gint", "gint", "guint"}, name ={"widget", "context", "x", "y", "time"}} }, 
    draw                        = {ret_type = "gboolean", params = {type = {"GtkWidget*", "cairo_t*"}, name ={"widget", "cr"}} }, 
    ['enter-notify-event']      = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventCrossing*"}, name ={"widget", "event"}} }, 
    event                       = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEvent*"}, name ={"widget", "event"}} }, 
    ['event-after']             = {ret_type = "void"    , params = {type = {"GtkWidget*", "GdkEvent*"}, name ={"widget", "event"}} }, 
    focus                       = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GtkDirectionType"}, name ={"widget", "direction"}} }, 
    ['focus-in-event']          = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventFocus*"}, name ={"widget", "event"}} }, 
    ['focus-out-event']         = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventFocus*"}, name ={"widget", "event"}} }, 
    ['grab-broken-event']       = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventGrabBroken*"}, name ={"widget", "event"}} }, 
    ['grab-focus']              = {ret_type = "void"    , params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    ['grab-notify']             = {ret_type = "void"    , params = {type = {"GtkWidget*", "gboolean"}, name ={"widget", "was_grabbed"}} }, 
    hide                        = {ret_type = "void"    , params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    ['hierarchy-changed']       = {ret_type = "void"    , params = {type = {"GtkWidget*", "GtkWidget*"}, name ={"widget", "previous_toplevel"}} }, 
    ['key-press-event']         = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventKey*"}, name ={"widget", "event"}} }, 
    ['key-release-event']       = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventKey*"}, name ={"widget", "event"}} }, 
    ['keynav-failed']           = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GtkDirectionType"}, name ={"widget", "direction"}} }, 
    ['leave-notify-event']      = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventCrossing*"}, name ={"widget", "event"}} }, 
    map                         = {ret_type = "void"    , params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    ['map-event']               = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventAny*"}, name ={"widget", "event"}} }, 
    ['mnemonic-activate']       = {ret_type = "gboolean", params = {type = {"GtkWidget*", "gboolean"}, name ={"widget", "group_cycling"}} }, 
    ['motion-notify-event']     = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventMotion*"}, name ={"widget", "event"}} }, 
    ['move-focus']              = {ret_type = "void"    , params = {type = {"GtkWidget*", "GtkDirectionType"}, name ={"widget", "direction"}} }, 
    ['parent-set']              = {ret_type = "void"    , params = {type = {"GtkWidget*", "GtkWidget*"}, name ={"widget", "old_parent"}} }, 
    ['popup-menu']              = {ret_type = "gboolean", params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    ['property-notify-event']   = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventProperty*"}, name ={"widget", "event"}} }, 
    ['proximity-in-event']      = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventProximity*"}, name ={"widget", "event"}} }, 
    ['proximity-out-event']     = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventProximity*"}, name ={"widget", "event"}} }, 
    ['query-tooltip']           = {ret_type = "gboolean", params = {type = {"GtkWidget*", "gint", "gint", "gboolean", "GtkTooltip*"}, name ={"widget", "x", "y", "keyboard_mode", "tooltip"}} }, 
    realize                     = {ret_type = "void"    , params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    ['screen-changed']          = {ret_type = "void"    , params = {type = {"GtkWidget*", "GdkScreen*"}, name ={"widget", "previous_screen"}} }, 
    ['scroll-event']            = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventScroll*"}, name ={"widget", "event"}} }, 
    ['selection-clear-event']   = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventSelection*"}, name ={"widget", "event"}} }, 
    ['selection-get']           = {ret_type = "void"    , params = {type = {"GtkWidget*", "GtkSelectionData*", "guint", "guint"}, name ={"widget", "data", "info", "time"}} }, 
    ['selection-notify-event']  = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventSelection*"}, name ={"widget", "event"}} }, 
    ['selection-received']      = {ret_type = "void"    , params = {type = {"GtkWidget*", "GtkSelectionData*", "guint"}, name ={"widget", "data", "time"}} }, 
    ['selection-request-event'] = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventSelection*"}, name ={"widget", "event"}} }, 
    show                        = {ret_type = "void"    , params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    ['show-help']               = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GtkWidgetHelpType"}, name ={"widget", "help_type"}} }, 
    ['size-allocate']           = {ret_type = "void"    , params = {type = {"GtkWidget*", "GtkAllocation*"}, name ={"widget", "allocation"}} }, 
    ['state-changed']           = {ret_type = "void"    , params = {type = {"GtkWidget*", "GtkStateType"}, name ={"widget", "state"}} }, 
    ['state-flags-changed']     = {ret_type = "void"    , params = {type = {"GtkWidget*", "GtkStateFlags*"}, name ={"widget", "flags"}} }, 
    ['style-set']               = {ret_type = "void"    , params = {type = {"GtkWidget*", "GtkStyle*"}, name ={"widget", "previous_style"}} }, 
    ['style-updated']           = {ret_type = "void"    , params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    ['touch-event']             = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEvent*"}, name ={"widget", "object"}} }, 
    unmap                       = {ret_type = "void"    , params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    ['unmap-event']             = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventAny*"}, name ={"widget", "event"}} }, 
    unrealize                   = {ret_type = "void"    , params = {type = {"GtkWidget*"}, name ={"widget"}} }, 
    ['visibility-notify-event'] = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventVisibility*"}, name ={"widget", "event"}} }, 
    ['window-state-event']      = {ret_type = "gboolean", params = {type = {"GtkWidget*", "GdkEventWindowState*"}, name ={"widget", "event"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["app-paintable"]    = {__type__="gboolean"      ,__default__ = "FALSE"              , __gencode__ = {"gtk_widget_set_app_paintable((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    ["can-default"]      = {__type__="gboolean"      ,__default__ = "FALSE"              , __gencode__ = {"gtk_widget_set_can_default((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    ["can-focus"]        = {__type__="gboolean"      ,__default__ = "FALSE"              , __gencode__ = {"gtk_widget_set_can_focus((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    ["composite-child"]  = {__type__="gboolean"      ,__default__ = "FALSE"               },
    ["double-buffered"]  = {__type__="gboolean"      ,__default__ = "TRUE"               , __gencode__ = {"gtk_widget_set_double_buffered((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    events               = {__type__="GdkEventMask"  ,__default__ = "GDK_STRUCTURE_MASK" , __gencode__ = {"gtk_widget_set_events((GtkWidget*)({* id *}), (gint)({* property.value *}))"} },
    expand               = {__type__="gboolean"      ,__default__ = "FALSE"              ,rwflags="rw" },
    ["focus-on-click"]   = {__type__="gboolean"      ,__default__ = "TRUE"               , __gencode__ = {"gtk_widget_set_focus_on_click((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    halign               = {__type__="GtkAlign"      ,__default__ = "GTK_ALIGN_FILL"     , __gencode__ = {"gtk_widget_set_halign((GtkWidget*)({* id *}), (GtkAlign)({* property.value *}))"} },
    ["has-default"]      = {__type__="gboolean"      ,__default__ = "FALSE"              ,rwflags="rw" },
    ["has-focus"]        = {__type__="gboolean"      ,__default__ = "FALSE"              ,rwflags="rw" },
    ["has-tooltip"]      = {__type__="gboolean"      ,__default__ = "FALSE"              , __gencode__ = {"gtk_widget_set_has_tooltip((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    ["height-request"]   = {__type__="gint"          ,__default__ = "-1"                 ,rwflags="rw" },
    hexpand              = {__type__="gboolean"      ,__default__ = "FALSE"              , __gencode__ = {"gtk_widget_set_hexpand((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    ["hexpand-set"]      = {__type__="gboolean"      ,__default__ = "FALSE"              , __gencode__ = {"gtk_widget_set_hexpand_set((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    ["is-focus"]         = {__type__="gboolean"      ,__default__ = "FALSE"              ,rwflags="rw" },
    margin               = {__type__="gint"          ,__default__ = "0"                  ,rwflags="rw" },
    ["margin-bottom"]    = {__type__="gint"          ,__default__ = "0"                  , __gencode__ = {"gtk_widget_set_margin_bottom((GtkWidget*)({* id *}), (gint)({* property.value *}))"} },
    ["margin-end"]       = {__type__="gint"          ,__default__ = "0"                  , __gencode__ = {"gtk_widget_set_margin_end((GtkWidget*)({* id *}), (gint)({* property.value *}))"} },
    ["margin-left"]      = {__type__="gint"          ,__default__ = "0"                  , __gencode__ = {"gtk_widget_set_margin_left((GtkWidget*)({* id *}), (gint)({* property.value *}))"} },
    ["margin-right"]     = {__type__="gint"          ,__default__ = "0"                  , __gencode__ = {"gtk_widget_set_margin_right((GtkWidget*)({* id *}), (gint)({* property.value *}))"} },
    ["margin-start"]     = {__type__="gint"          ,__default__ = "0"                  , __gencode__ = {"gtk_widget_set_margin_start((GtkWidget*)({* id *}), (gint)({* property.value *}))"} },
    ["margin-top"]       = {__type__="gint"          ,__default__ = "0"                  , __gencode__ = {"gtk_widget_set_margin_top((GtkWidget*)({* id *}), (gint)({* property.value *}))"} },
    name                 = {__type__="gchar*"        ,__default__ = "NULL"               , __gencode__ = {"gtk_widget_set_name((GtkWidget*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["no-show-all"]      = {__type__="gboolean"      ,__default__ = "FALSE"              , __gencode__ = {"gtk_widget_set_no_show_all((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    opacity              = {__type__="gdouble"       ,__default__ = "1"                  , __gencode__ = {"gtk_widget_set_opacity((GtkWidget*)({* id *}), (double)({* property.value *}))"} },
    parent               = {__type__="GtkContainer*"                                     , __gencode__ = {"gtk_widget_set_parent((GtkWidget*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["receives-default"] = {__type__="gboolean"      ,__default__ = "FALSE"              , __gencode__ = {"gtk_widget_set_receives_default((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    ["scale-factor"]     = {__type__="gint"          ,__default__ = "1"                   },
    sensitive            = {__type__="gboolean"      ,__default__ = "TRUE"               , __gencode__ = {"gtk_widget_set_sensitive((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    style                = {__type__="GtkStyle*"                                         , __gencode__ = {"gtk_widget_set_style((GtkWidget*)({* id *}), (GtkStyle*)({* property.value *}))"} },
    ["tooltip-markup"]   = {__type__="gchar*"        ,__default__ = "NULL"               , __gencode__ = {"gtk_widget_set_tooltip_markup((GtkWidget*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["tooltip-text"]     = {__type__="gchar*"        ,__default__ = "NULL"               , __gencode__ = {"gtk_widget_set_tooltip_text((GtkWidget*)({* id *}), (const gchar*)({* property.value *}))"} },
    valign               = {__type__="GtkAlign"      ,__default__ = "GTK_ALIGN_FILL"     , __gencode__ = {"gtk_widget_set_valign((GtkWidget*)({* id *}), (GtkAlign)({* property.value *}))"} },
    vexpand              = {__type__="gboolean"      ,__default__ = "FALSE"              , __gencode__ = {"gtk_widget_set_vexpand((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    ["vexpand-set"]      = {__type__="gboolean"      ,__default__ = "FALSE"              , __gencode__ = {"gtk_widget_set_vexpand_set((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    visible              = {__type__="gboolean"      ,__default__ = "FALSE"              , __gencode__ = {"gtk_widget_set_visible((GtkWidget*)({* id *}), (gboolean)({* property.value *}))"} },
    ["width-request"]    = {__type__="gint"          ,__default__ = "-1"                 ,rwflags="rw" },
    window               = {__type__="GdkWindow*"                                        , __gencode__ = {"gtk_widget_set_window((GtkWidget*)({* id *}), (GdkWindow*)({* property.value *}))"},rwflags="r" },
  },
  parent = nil, 
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkWindowGroup
Gtk324.GtkWindowGroup = {
  class = "GtkWindowGroup", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_window_group_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = nil, 
};

---------------------  GtkCalendar
Gtk324.GtkCalendar = {
  class = "GtkCalendar", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_calendar_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    day_selected              = {"void", {"GtkCalendar*"}, {"calendar"} }, 
    day_selected_double_click = {"void", {"GtkCalendar*"}, {"calendar"} }, 
    month_changed             = {"void", {"GtkCalendar*"}, {"calendar"} }, 
    next_month                = {"void", {"GtkCalendar*"}, {"calendar"} }, 
    next_year                 = {"void", {"GtkCalendar*"}, {"calendar"} }, 
    prev_month                = {"void", {"GtkCalendar*"}, {"calendar"} }, 
    prev_year                 = {"void", {"GtkCalendar*"}, {"calendar"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['day-selected']              = {ret_type = "void", params = {type = {"GtkCalendar*"}, name ={"calendar"}} }, 
    ['day-selected-double-click'] = {ret_type = "void", params = {type = {"GtkCalendar*"}, name ={"calendar"}} }, 
    ['month-changed']             = {ret_type = "void", params = {type = {"GtkCalendar*"}, name ={"calendar"}} }, 
    ['next-month']                = {ret_type = "void", params = {type = {"GtkCalendar*"}, name ={"calendar"}} }, 
    ['next-year']                 = {ret_type = "void", params = {type = {"GtkCalendar*"}, name ={"calendar"}} }, 
    ['prev-month']                = {ret_type = "void", params = {type = {"GtkCalendar*"}, name ={"calendar"}} }, 
    ['prev-year']                 = {ret_type = "void", params = {type = {"GtkCalendar*"}, name ={"calendar"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    day                    = {__type__="gint"     ,__default__ = "0"     ,rwflags="rw" },
    ["detail-height-rows"] = {__type__="gint"     ,__default__ = "0"     , __gencode__ = {"gtk_calendar_set_detail_height_rows((GtkCalendar*)({* id *}), (gint)({* property.value *}))"} },
    ["detail-width-chars"] = {__type__="gint"     ,__default__ = "0"     , __gencode__ = {"gtk_calendar_set_detail_width_chars((GtkCalendar*)({* id *}), (gint)({* property.value *}))"} },
    month                  = {__type__="gint"     ,__default__ = "0"     ,rwflags="rw" },
    ["no-month-change"]    = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
    ["show-day-names"]     = {__type__="gboolean" ,__default__ = "TRUE"  ,rwflags="rw" },
    ["show-details"]       = {__type__="gboolean" ,__default__ = "TRUE"  ,rwflags="rw" },
    ["show-heading"]       = {__type__="gboolean" ,__default__ = "TRUE"  ,rwflags="rw" },
    ["show-week-numbers"]  = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
    year                   = {__type__="gint"     ,__default__ = "0"     ,rwflags="rw" },
  },
  parent = Gtk324.GtkWidget,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkCellAccessible
Gtk324.GtkCellAccessible = {
  class = "GtkCellAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    update_cache = {"void", {"GtkCellAccessible*", "gboolean"}, {"cell", "emit_signal"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkAccessible,
};

---------------------  GtkCellAreaBox
Gtk324.GtkCellAreaBox = {
  class = "GtkCellAreaBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_cell_area_box_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    spacing = {__type__="gint" ,__default__ = "0" , __gencode__ = {"gtk_cell_area_box_set_spacing((GtkCellAreaBox*)({* id *}), (gint)({* property.value *}))"} },
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    align          = {__type__="gboolean"    ,__default__ = "FALSE" },
    expand         = {__type__="gboolean"    ,__default__ = "FALSE" },
    ["fixed-size"] = {__type__="gboolean"    ,__default__ = "TRUE" },
    ["pack-type"]  = {__type__="GtkPackType" ,__default__ = "GTK_PACK_START" },
  },
  parent = Gtk324.GtkCellArea,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkCellLayout, Gtk324.GtkOrientable}, 
};

---------------------  GtkCellRendererPixbuf
Gtk324.GtkCellRendererPixbuf = {
  class = "GtkCellRendererPixbuf", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_cell_renderer_pixbuf_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["follow-state"]           = {__type__="gboolean"      ,__default__ = "TRUE" ,rwflags="rw" },
    gicon                      = {__type__="GIcon*"                              ,rwflags="rw" },
    ["icon-name"]              = {__type__="gchar*"        ,__default__ = "NULL" ,rwflags="rw" },
    pixbuf                     = {__type__="GdkPixbuf*"                          ,rwflags="rw" },
    ["pixbuf-expander-closed"] = {__type__="GdkPixbuf*"                          ,rwflags="rw" },
    ["pixbuf-expander-open"]   = {__type__="GdkPixbuf*"                          ,rwflags="rw" },
    ["stock-detail"]           = {__type__="gchar*"        ,__default__ = "NULL" ,rwflags="rw" },
    ["stock-id"]               = {__type__="gchar*"        ,__default__ = "NULL" ,rwflags="rw" },
    ["stock-size"]             = {__type__="guint"         ,__default__ = "1"    ,rwflags="rw" },
    surface                    = {__type__="CairoSurface*"                       ,rwflags="rw" },
  },
  parent = Gtk324.GtkCellRenderer,
};

---------------------  GtkCellRendererProgress
Gtk324.GtkCellRendererProgress = {
  class = "GtkCellRendererProgress", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_cell_renderer_progress_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    inverted        = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
    pulse           = {__type__="gint"     ,__default__ = "-1"    ,rwflags="rw" },
    text            = {__type__="gchar*"   ,__default__ = "NULL"  ,rwflags="rw" },
    ["text-xalign"] = {__type__="gfloat"   ,__default__ = "0.5"   ,rwflags="rw" },
    ["text-yalign"] = {__type__="gfloat"   ,__default__ = "0.5"   ,rwflags="rw" },
    value           = {__type__="gint"     ,__default__ = "0"     ,rwflags="rw" },
  },
  parent = Gtk324.GtkCellRenderer,
  implement = {Gtk324.GtkOrientable}, 
};

---------------------  GtkCellRendererSpinner
Gtk324.GtkCellRendererSpinner = {
  class = "GtkCellRendererSpinner", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_cell_renderer_spinner_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    active = {__type__="gboolean"    ,__default__ = "FALSE"              ,rwflags="rw" },
    pulse  = {__type__="guint"       ,__default__ = "0"                  ,rwflags="rw" },
    size   = {__type__="GtkIconSize" ,__default__ = "GTK_ICON_SIZE_MENU" ,rwflags="rw" },
  },
  parent = Gtk324.GtkCellRenderer,
};

---------------------  GtkCellRendererText
Gtk324.GtkCellRendererText = {
  class = "GtkCellRendererText", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_cell_renderer_text_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    edited = {"void", {"GtkCellRendererText*", "const gchar*", "const gchar*"}, {"cell_renderer_text", "path", "new_text"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    edited = {ret_type = "void", params = {type = {"GtkCellRendererText*", "const gchar*", "const gchar*"}, name ={"cell_renderer_text", "path", "new_text"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["align-set"]             = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    alignment                 = {__type__="PangoAlignment"        ,__default__ = "PANGO_ALIGN_LEFT"     ,rwflags="rw" },
    attributes                = {__type__="PangoAttrList*"                                              ,rwflags="rw" },
    background                = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="w" },
    ["background-gdk"]        = {__type__="GdkColor*"                                                   ,rwflags="rw" },
    ["background-rgba"]       = {__type__="GdkRGBA*"                                                    ,rwflags="rw" },
    ["background-set"]        = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    editable                  = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    ["editable-set"]          = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    ellipsize                 = {__type__="PangoEllipsizeMode"    ,__default__ = "PANGO_ELLIPSIZE_NONE" ,rwflags="rw" },
    ["ellipsize-set"]         = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    family                    = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="rw" },
    ["family-set"]            = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    font                      = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="rw" },
    ["font-desc"]             = {__type__="PangoFontDescription*"                                       ,rwflags="rw" },
    foreground                = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="w" },
    ["foreground-gdk"]        = {__type__="GdkColor*"                                                   ,rwflags="rw" },
    ["foreground-rgba"]       = {__type__="GdkRGBA*"                                                    ,rwflags="rw" },
    ["foreground-set"]        = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    language                  = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="rw" },
    ["language-set"]          = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    markup                    = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="w" },
    ["max-width-chars"]       = {__type__="gint"                  ,__default__ = "-1"                   ,rwflags="rw" },
    ["placeholder-text"]      = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="rw" },
    rise                      = {__type__="gint"                  ,__default__ = "0"                    ,rwflags="rw" },
    ["rise-set"]              = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    scale                     = {__type__="gdouble"               ,__default__ = "1"                    ,rwflags="rw" },
    ["scale-set"]             = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    ["single-paragraph-mode"] = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    size                      = {__type__="gint"                  ,__default__ = "0"                    ,rwflags="rw" },
    ["size-points"]           = {__type__="gdouble"               ,__default__ = "0"                    ,rwflags="rw" },
    ["size-set"]              = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    stretch                   = {__type__="PangoStretch"          ,__default__ = "PANGO_STRETCH_NORMAL" ,rwflags="rw" },
    ["stretch-set"]           = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    strikethrough             = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    ["strikethrough-set"]     = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    style                     = {__type__="PangoStyle"            ,__default__ = "PANGO_STYLE_NORMAL"   ,rwflags="rw" },
    ["style-set"]             = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    text                      = {__type__="gchar*"                ,__default__ = "NULL"                 ,rwflags="rw" },
    underline                 = {__type__="PangoUnderline"        ,__default__ = "PANGO_UNDERLINE_NONE" ,rwflags="rw" },
    ["underline-set"]         = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    variant                   = {__type__="PangoVariant"          ,__default__ = "PANGO_VARIANT_NORMAL" ,rwflags="rw" },
    ["variant-set"]           = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    weight                    = {__type__="gint"                  ,__default__ = "400"                  ,rwflags="rw" },
    ["weight-set"]            = {__type__="gboolean"              ,__default__ = "FALSE"                ,rwflags="rw" },
    ["width-chars"]           = {__type__="gint"                  ,__default__ = "-1"                   ,rwflags="rw" },
    ["wrap-mode"]             = {__type__="PangoWrapMode"         ,__default__ = "PANGO_WRAP_CHAR"      ,rwflags="rw" },
    ["wrap-width"]            = {__type__="gint"                  ,__default__ = "-1"                   ,rwflags="rw" },
  },
  parent = Gtk324.GtkCellRenderer,
};

---------------------  GtkCellRendererToggle
Gtk324.GtkCellRendererToggle = {
  class = "GtkCellRendererToggle", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_cell_renderer_toggle_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    toggled = {"void", {"GtkCellRendererToggle*", "const gchar*"}, {"cell_renderer_toggle", "path"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    toggled = {ret_type = "void", params = {type = {"GtkCellRendererToggle*", "const gchar*"}, name ={"cell_renderer_toggle", "path"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    activatable        = {__type__="gboolean" ,__default__ = "TRUE"  , __gencode__ = {"gtk_cell_renderer_toggle_set_activatable((GtkCellRendererToggle*)({* id *}), (gboolean)({* property.value *}))"} },
    active             = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_cell_renderer_toggle_set_active((GtkCellRendererToggle*)({* id *}), (gboolean)({* property.value *}))"} },
    inconsistent       = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
    ["indicator-size"] = {__type__="gint"     ,__default__ = "0"     ,rwflags="rw" },
    radio              = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_cell_renderer_toggle_set_radio((GtkCellRendererToggle*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk324.GtkCellRenderer,
};

---------------------  GtkCellView
Gtk324.GtkCellView = {
  class = "GtkCellView", 
  constructor = { 
    -- 名称[- ==> _], 
    new              = { gencode = "gtk_cell_view_new()", 
            params = { type = {}, name = {} } },
    new_with_context = { gencode = "gtk_cell_view_new_with_context((GtkCellArea*)({* this.area.value *}), (GtkCellAreaContext*)({* this.context.value *}))", 
            params = { type = {}, name = {} } },
    new_with_markup  = { gencode = "gtk_cell_view_new_with_markup((const gchar*)({* this.markup.value *}))", 
            params = { type = {}, name = {} } },
    new_with_pixbuf  = { gencode = "gtk_cell_view_new_with_pixbuf((GdkPixbuf*)({* this.pixbuf.value *}))", 
            params = { type = {}, name = {} } },
    new_with_text    = { gencode = "gtk_cell_view_new_with_text((const gchar*)({* this.text.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    background            = {__type__="gchar*"              ,__default__ = "NULL"  ,rwflags="w" },
    ["background-gdk"]    = {__type__="GdkColor*"                                  ,rwflags="rw" },
    ["background-rgba"]   = {__type__="GdkRGBA*"                                   , __gencode__ = {"gtk_cell_view_set_background_rgba((GtkCellView*)({* id *}), (const GdkRGBA*)({* property.value *}))"} },
    ["background-set"]    = {__type__="gboolean"            ,__default__ = "FALSE" ,rwflags="rw" },
    ["cell-area"]         = {__type__="GtkCellArea*"                               ,rwflags="rw" },
    ["cell-area-context"] = {__type__="GtkCellAreaContext*"                        ,rwflags="rw" },
    ["draw-sensitive"]    = {__type__="gboolean"            ,__default__ = "FALSE" , __gencode__ = {"gtk_cell_view_set_draw_sensitive((GtkCellView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["fit-model"]         = {__type__="gboolean"            ,__default__ = "FALSE" , __gencode__ = {"gtk_cell_view_set_fit_model((GtkCellView*)({* id *}), (gboolean)({* property.value *}))"} },
    model                 = {__type__="GtkTreeModel*"                              , __gencode__ = {"gtk_cell_view_set_model((GtkCellView*)({* id *}), (GtkTreeModel*)({* property.value *}))"} },
  },
  parent = Gtk324.GtkWidget,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkCellLayout, Gtk324.GtkOrientable}, 
};

---------------------  GtkContainer
Gtk324.GtkContainer = {
  class = "GtkContainer", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    add                = {"void"          , {"GtkContainer*", "GtkWidget*"}, {"container", "widget"} }, 
    check_resize       = {"void"          , {"GtkContainer*"}, {"container"} }, 
    child_type         = {"GType"         , {"GtkContainer*"}, {"container"} }, 
    composite_name     = {"gchar*"        , {"GtkContainer*", "GtkWidget*"}, {"container", "child"} }, 
    forall             = {"void"          , {"GtkContainer*", "gboolean", "GtkCallback", "gpointer"}, {"container", "include_internals", "callback", "callback_data"} }, 
    get_child_property = {"void"          , {"GtkContainer*", "GtkWidget*", "guint", "GValue*", "GParamSpec*"}, {"container", "child", "property_id", "value", "pspec"} }, 
    get_path_for_child = {"GtkWidgetPath*", {"GtkContainer*", "GtkWidget*"}, {"container", "child"} }, 
    remove             = {"void"          , {"GtkContainer*", "GtkWidget*"}, {"container", "widget"} }, 
    set_child_property = {"void"          , {"GtkContainer*", "GtkWidget*", "guint", "const GValue*", "GParamSpec*"}, {"container", "child", "property_id", "value", "pspec"} }, 
    set_focus_child    = {"void"          , {"GtkContainer*", "GtkWidget*"}, {"container", "child"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    add                 = {ret_type = "void", params = {type = {"GtkContainer*", "GtkWidget*"}, name ={"container", "widget"}} }, 
    ['check-resize']    = {ret_type = "void", params = {type = {"GtkContainer*"}, name ={"container"}} }, 
    remove              = {ret_type = "void", params = {type = {"GtkContainer*", "GtkWidget*"}, name ={"container", "widget"}} }, 
    ['set-focus-child'] = {ret_type = "void", params = {type = {"GtkContainer*", "GtkWidget*"}, name ={"container", "object"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["border-width"] = {__type__="guint"         ,__default__ = "0"                 , __gencode__ = {"gtk_container_set_border_width((GtkContainer*)({* id *}), (guint)({* property.value *}))"} },
    child            = {__type__="GtkWidget*"                                       ,rwflags="w" },
    ["resize-mode"]  = {__type__="GtkResizeMode" ,__default__ = "GTK_RESIZE_PARENT" , __gencode__ = {"gtk_container_set_resize_mode((GtkContainer*)({* id *}), (GtkResizeMode)({* property.value *}))"} },
  },
  parent = Gtk324.GtkWidget,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkDrawingArea
Gtk324.GtkDrawingArea = {
  class = "GtkDrawingArea", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_drawing_area_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkWidget,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkEntry
Gtk324.GtkEntry = {
  class = "GtkEntry", 
  constructor = { 
    -- 名称[- ==> _], 
    new             = { gencode = "gtk_entry_new()", 
            params = { type = {}, name = {} } },
    new_with_buffer = { gencode = "gtk_entry_new_with_buffer((GtkEntryBuffer*)({* this.buffer.value *}))", 
            params = { type = {"GtkEntryBuffer*"}, 
                       name = {"buffer"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate           = {"void", {"GtkEntry*"}, {"entry"} }, 
    backspace          = {"void", {"GtkEntry*"}, {"entry"} }, 
    copy_clipboard     = {"void", {"GtkEntry*"}, {"entry"} }, 
    cut_clipboard      = {"void", {"GtkEntry*"}, {"entry"} }, 
    delete_from_cursor = {"void", {"GtkEntry*", "GtkDeleteType", "gint"}, {"entry", "type", "count"} }, 
    get_frame_size     = {"void", {"GtkEntry*", "gint*", "gint*", "gint*", "gint*"}, {"entry", "x", "y", "width", "height"} }, 
    get_text_area_size = {"void", {"GtkEntry*", "gint*", "gint*", "gint*", "gint*"}, {"entry", "x", "y", "width", "height"} }, 
    insert_at_cursor   = {"void", {"GtkEntry*", "const gchar*"}, {"entry", "str"} }, 
    insert_emoji       = {"void", {"GtkEntry*"}, {"entry"} }, 
    move_cursor        = {"void", {"GtkEntry*", "GtkMovementStep", "gint", "gboolean"}, {"entry", "step", "count", "extend_selection"} }, 
    paste_clipboard    = {"void", {"GtkEntry*"}, {"entry"} }, 
    populate_popup     = {"void", {"GtkEntry*", "GtkWidget*"}, {"entry", "popup"} }, 
    toggle_direction   = {"void", {"GtkEntry*"}, {"entry"} }, 
    toggle_overwrite   = {"void", {"GtkEntry*"}, {"entry"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate               = {ret_type = "void", params = {type = {"GtkEntry*"}, name ={"entry"}} }, 
    backspace              = {ret_type = "void", params = {type = {"GtkEntry*"}, name ={"entry"}} }, 
    ['copy-clipboard']     = {ret_type = "void", params = {type = {"GtkEntry*"}, name ={"entry"}} }, 
    ['cut-clipboard']      = {ret_type = "void", params = {type = {"GtkEntry*"}, name ={"entry"}} }, 
    ['delete-from-cursor'] = {ret_type = "void", params = {type = {"GtkEntry*", "GtkDeleteType", "gint"}, name ={"entry", "type", "count"}} }, 
    ['icon-press']         = {ret_type = "void", params = {type = {"GtkEntry*", "GtkEntryIconPosition", "GdkEvent*"}, name ={"entry", "icon_pos", "event"}} }, 
    ['icon-release']       = {ret_type = "void", params = {type = {"GtkEntry*", "GtkEntryIconPosition", "GdkEvent*"}, name ={"entry", "icon_pos", "event"}} }, 
    ['insert-at-cursor']   = {ret_type = "void", params = {type = {"GtkEntry*", "gchar*"}, name ={"entry", "string"}} }, 
    ['insert-emoji']       = {ret_type = "void", params = {type = {"GtkEntry*"}, name ={"entry"}} }, 
    ['move-cursor']        = {ret_type = "void", params = {type = {"GtkEntry*", "GtkMovementStep", "gint", "gboolean"}, name ={"entry", "step", "count", "extend_selection"}} }, 
    ['paste-clipboard']    = {ret_type = "void", params = {type = {"GtkEntry*"}, name ={"entry"}} }, 
    ['populate-popup']     = {ret_type = "void", params = {type = {"GtkEntry*", "GtkWidget*"}, name ={"entry", "widget"}} }, 
    ['preedit-changed']    = {ret_type = "void", params = {type = {"GtkEntry*", "gchar*"}, name ={"entry", "preedit"}} }, 
    ['toggle-direction']   = {ret_type = "void", params = {type = {"GtkEntry*"}, name ={"entry"}} }, 
    ['toggle-overwrite']   = {ret_type = "void", params = {type = {"GtkEntry*"}, name ={"entry"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["activates-default"]             = {__type__="gboolean"            ,__default__ = "FALSE"                       , __gencode__ = {"gtk_entry_set_activates_default((GtkEntry*)({* id *}), (gboolean)({* property.value *}))"} },
    attributes                        = {__type__="PangoAttrList*"                                                   , __gencode__ = {"gtk_entry_set_attributes((GtkEntry*)({* id *}), (PangoAttrList*)({* property.value *}))"} },
    buffer                            = {__type__="GtkEntryBuffer*"                                                  , __gencode__ = {"gtk_entry_set_buffer((GtkEntry*)({* id *}), (GtkEntryBuffer*)({* property.value *}))"},__construct__= 1 },
    ["caps-lock-warning"]             = {__type__="gboolean"            ,__default__ = "TRUE"                        ,rwflags="rw" },
    completion                        = {__type__="GtkEntryCompletion*"                                              , __gencode__ = {"gtk_entry_set_completion((GtkEntry*)({* id *}), (GtkEntryCompletion*)({* property.value *}))"} },
    ["cursor-position"]               = {__type__="gint"                ,__default__ = "0"                            },
    editable                          = {__type__="gboolean"            ,__default__ = "TRUE"                        ,rwflags="rw" },
    ["enable-emoji-completion"]       = {__type__="gboolean"            ,__default__ = "FALSE"                       ,rwflags="rw" },
    ["has-frame"]                     = {__type__="gboolean"            ,__default__ = "TRUE"                        , __gencode__ = {"gtk_entry_set_has_frame((GtkEntry*)({* id *}), (gboolean)({* property.value *}))"} },
    ["im-module"]                     = {__type__="gchar*"              ,__default__ = "NULL"                        ,rwflags="rw" },
    ["inner-border"]                  = {__type__="GtkBorder*"                                                       , __gencode__ = {"gtk_entry_set_inner_border((GtkEntry*)({* id *}), (const GtkBorder*)({* property.value *}))"} },
    ["input-hints"]                   = {__type__="GtkInputHints"                                                    , __gencode__ = {"gtk_entry_set_input_hints((GtkEntry*)({* id *}), (GtkInputHints)({* property.value *}))"} },
    ["input-purpose"]                 = {__type__="GtkInputPurpose"     ,__default__ = "GTK_INPUT_PURPOSE_FREE_FORM" , __gencode__ = {"gtk_entry_set_input_purpose((GtkEntry*)({* id *}), (GtkInputPurpose)({* property.value *}))"} },
    ["invisible-char"]                = {__type__="guint"               ,__default__ = "'*'"                         , __gencode__ = {"gtk_entry_set_invisible_char((GtkEntry*)({* id *}), (gunichar)({* property.value *}))"} },
    ["invisible-char-set"]            = {__type__="gboolean"            ,__default__ = "FALSE"                       ,rwflags="rw" },
    ["max-length"]                    = {__type__="gint"                ,__default__ = "0"                           , __gencode__ = {"gtk_entry_set_max_length((GtkEntry*)({* id *}), (gint)({* property.value *}))"} },
    ["max-width-chars"]               = {__type__="gint"                ,__default__ = "-1"                          , __gencode__ = {"gtk_entry_set_max_width_chars((GtkEntry*)({* id *}), (gint)({* property.value *}))"} },
    ["overwrite-mode"]                = {__type__="gboolean"            ,__default__ = "FALSE"                       , __gencode__ = {"gtk_entry_set_overwrite_mode((GtkEntry*)({* id *}), (gboolean)({* property.value *}))"} },
    ["placeholder-text"]              = {__type__="gchar*"              ,__default__ = "NULL"                        , __gencode__ = {"gtk_entry_set_placeholder_text((GtkEntry*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["populate-all"]                  = {__type__="gboolean"            ,__default__ = "FALSE"                       ,rwflags="rw" },
    ["primary-icon-activatable"]      = {__type__="gboolean"            ,__default__ = "TRUE"                        ,rwflags="rw" },
    ["primary-icon-gicon"]            = {__type__="GIcon*"                                                           ,rwflags="rw" },
    ["primary-icon-name"]             = {__type__="gchar*"              ,__default__ = "NULL"                        ,rwflags="rw" },
    ["primary-icon-pixbuf"]           = {__type__="GdkPixbuf*"                                                       ,rwflags="rw" },
    ["primary-icon-sensitive"]        = {__type__="gboolean"            ,__default__ = "TRUE"                        ,rwflags="rw" },
    ["primary-icon-stock"]            = {__type__="gchar*"              ,__default__ = "NULL"                        ,rwflags="rw" },
    ["primary-icon-storage-type"]     = {__type__="GtkImageType"        ,__default__ = "GTK_IMAGE_EMPTY"              },
    ["primary-icon-tooltip-markup"]   = {__type__="gchar*"              ,__default__ = "NULL"                        ,rwflags="rw" },
    ["primary-icon-tooltip-text"]     = {__type__="gchar*"              ,__default__ = "NULL"                        ,rwflags="rw" },
    ["progress-fraction"]             = {__type__="gdouble"             ,__default__ = "0"                           , __gencode__ = {"gtk_entry_set_progress_fraction((GtkEntry*)({* id *}), (gdouble)({* property.value *}))"} },
    ["progress-pulse-step"]           = {__type__="gdouble"             ,__default__ = "0.1"                         , __gencode__ = {"gtk_entry_set_progress_pulse_step((GtkEntry*)({* id *}), (gdouble)({* property.value *}))"} },
    ["scroll-offset"]                 = {__type__="gint"                ,__default__ = "0"                            },
    ["secondary-icon-activatable"]    = {__type__="gboolean"            ,__default__ = "TRUE"                        ,rwflags="rw" },
    ["secondary-icon-gicon"]          = {__type__="GIcon*"                                                           ,rwflags="rw" },
    ["secondary-icon-name"]           = {__type__="gchar*"              ,__default__ = "NULL"                        ,rwflags="rw" },
    ["secondary-icon-pixbuf"]         = {__type__="GdkPixbuf*"                                                       ,rwflags="rw" },
    ["secondary-icon-sensitive"]      = {__type__="gboolean"            ,__default__ = "TRUE"                        ,rwflags="rw" },
    ["secondary-icon-stock"]          = {__type__="gchar*"              ,__default__ = "NULL"                        ,rwflags="rw" },
    ["secondary-icon-storage-type"]   = {__type__="GtkImageType"        ,__default__ = "GTK_IMAGE_EMPTY"              },
    ["secondary-icon-tooltip-markup"] = {__type__="gchar*"              ,__default__ = "NULL"                        ,rwflags="rw" },
    ["secondary-icon-tooltip-text"]   = {__type__="gchar*"              ,__default__ = "NULL"                        ,rwflags="rw" },
    ["selection-bound"]               = {__type__="gint"                ,__default__ = "0"                            },
    ["shadow-type"]                   = {__type__="GtkShadowType"       ,__default__ = "GTK_SHADOW_IN"               ,rwflags="rw" },
    ["show-emoji-icon"]               = {__type__="gboolean"            ,__default__ = "FALSE"                       ,rwflags="rw" },
    tabs                              = {__type__="PangoTabArray*"                                                   , __gencode__ = {"gtk_entry_set_tabs((GtkEntry*)({* id *}), (PangoTabArray*)({* property.value *}))"} },
    text                              = {__type__="gchar*"              ,__default__ = "\"\""                        , __gencode__ = {"gtk_entry_set_text((GtkEntry*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["text-length"]                   = {__type__="guint"               ,__default__ = "0"                            },
    ["truncate-multiline"]            = {__type__="gboolean"            ,__default__ = "FALSE"                       ,rwflags="rw" },
    visibility                        = {__type__="gboolean"            ,__default__ = "TRUE"                        , __gencode__ = {"gtk_entry_set_visibility((GtkEntry*)({* id *}), (gboolean)({* property.value *}))"} },
    ["width-chars"]                   = {__type__="gint"                ,__default__ = "-1"                          , __gencode__ = {"gtk_entry_set_width_chars((GtkEntry*)({* id *}), (gint)({* property.value *}))"} },
    xalign                            = {__type__="gfloat"              ,__default__ = "0"                           ,rwflags="rw" },
  },
  parent = Gtk324.GtkWidget,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkCellEditable, Gtk324.GtkEditable}, 
};

---------------------  GtkEventControllerKey
Gtk324.GtkEventControllerKey = {
  class = "GtkEventControllerKey", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_event_controller_key_new((GtkWidget*)({* this.widget.value *}))", 
            params = { type = {"GtkWidget*"}, 
                       name = {"widget"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['focus-in']     = {ret_type = "void"    , params = {type = {"GtkEventControllerKey*"}, name ={"eventcontrollerkey"}} }, 
    ['focus-out']    = {ret_type = "void"    , params = {type = {"GtkEventControllerKey*"}, name ={"eventcontrollerkey"}} }, 
    ['im-update']    = {ret_type = "void"    , params = {type = {"GtkEventControllerKey*"}, name ={"eventcontrollerkey"}} }, 
    ['key-pressed']  = {ret_type = "gboolean", params = {type = {"GtkEventControllerKey*", "guint", "guint", "GdkModifierType*"}, name ={"eventcontrollerkey", "keyval", "keycode", "state"}} }, 
    ['key-released'] = {ret_type = "void"    , params = {type = {"GtkEventControllerKey*", "guint", "guint", "GdkModifierType*"}, name ={"eventcontrollerkey", "keyval", "keycode", "state"}} }, 
    modifiers        = {ret_type = "gboolean", params = {type = {"GtkEventControllerKey*", "GdkModifierType*"}, name ={"eventcontrollerkey", "object"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkEventController,
};

---------------------  GtkEventControllerMotion
Gtk324.GtkEventControllerMotion = {
  class = "GtkEventControllerMotion", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_event_controller_motion_new((GtkWidget*)({* this.widget.value *}))", 
            params = { type = {"GtkWidget*"}, 
                       name = {"widget"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    enter  = {ret_type = "void", params = {type = {"GtkEventControllerMotion*", "gdouble", "gdouble"}, name ={"eventcontrollermotion", "x", "y"}} }, 
    leave  = {ret_type = "void", params = {type = {"GtkEventControllerMotion*"}, name ={"eventcontrollermotion"}} }, 
    motion = {ret_type = "void", params = {type = {"GtkEventControllerMotion*", "gdouble", "gdouble"}, name ={"eventcontrollermotion", "x", "y"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkEventController,
};

---------------------  GtkEventControllerScroll
Gtk324.GtkEventControllerScroll = {
  class = "GtkEventControllerScroll", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_event_controller_scroll_new((GtkWidget*)({* this.widget.value *}), (GtkEventControllerScrollFlags)({* this.flags.value *}))", 
            params = { type = {"GtkWidget*", "GtkEventControllerScrollFlags"}, 
                       name = {"widget", "flags"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    decelerate       = {ret_type = "void", params = {type = {"GtkEventControllerScroll*", "gdouble", "gdouble"}, name ={"eventcontrollerscroll", "vel_x", "vel_y"}} }, 
    scroll           = {ret_type = "void", params = {type = {"GtkEventControllerScroll*", "gdouble", "gdouble"}, name ={"eventcontrollerscroll", "dx", "dy"}} }, 
    ['scroll-begin'] = {ret_type = "void", params = {type = {"GtkEventControllerScroll*"}, name ={"eventcontrollerscroll"}} }, 
    ['scroll-end']   = {ret_type = "void", params = {type = {"GtkEventControllerScroll*"}, name ={"eventcontrollerscroll"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    flags = {__type__="GtkEventControllerScrollFlags" , __gencode__ = {"gtk_event_controller_scroll_set_flags((GtkEventControllerScroll*)({* id *}), (GtkEventControllerScrollFlags)({* property.value *}))"} },
  },
  parent = Gtk324.GtkEventController,
};

---------------------  GtkFileChooserNative
Gtk324.GtkFileChooserNative = {
  class = "GtkFileChooserNative", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_file_chooser_native_new((const gchar*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}), (GtkFileChooserAction)({* this.action.value *}), (const gchar*)({* this['accept-label'].value *}), (const gchar*)({* this['cancel-label'].value *}))", 
            params = { type = {"const gchar*", "GtkFileChooserAction", "const gchar*", "const gchar*"}, 
                       name = {"title", "action", "accept-label", "cancel-label"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["accept-label"] = {__type__="gchar*" , __gencode__ = {"gtk_file_chooser_native_set_accept_label((GtkFileChooserNative*)({* id *}), (const char*)({* property.value *}))"} },
    ["cancel-label"] = {__type__="gchar*" , __gencode__ = {"gtk_file_chooser_native_set_cancel_label((GtkFileChooserNative*)({* id *}), (const char*)({* property.value *}))"} },
  },
  parent = Gtk324.GtkNativeDialog,
  implement = {Gtk324.GtkFileChooser}, 
};

---------------------  GtkGLArea
Gtk324.GtkGLArea = {
  class = "GtkGLArea", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_gl_area_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    create_context = {"GdkGLContext*", {"GtkGLArea*"}, {"area"} }, 
    render         = {"gboolean"     , {"GtkGLArea*", "GdkGLContext*"}, {"area", "context"} }, 
    resize         = {"void"         , {"GtkGLArea*", "int", "int"}, {"area", "width", "height"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['create-context'] = {ret_type = "{Gdk.GLContext}", params = {type = {"GtkGLArea*"}, name ={"glarea"}} }, 
    render             = {ret_type = "gboolean"       , params = {type = {"GtkGLArea*", "GdkGLContext*"}, name ={"area", "context"}} }, 
    resize             = {ret_type = "void"           , params = {type = {"GtkGLArea*", "int", "int"}, name ={"area", "width", "height"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["auto-render"]        = {__type__="gboolean"      ,__default__ = "TRUE"  , __gencode__ = {"gtk_gl_area_set_auto_render((GtkGLArea*)({* id *}), (gboolean)({* property.value *}))"} },
    context                = {__type__="GdkGLContext*"                         },
    ["has-alpha"]          = {__type__="gboolean"      ,__default__ = "FALSE" , __gencode__ = {"gtk_gl_area_set_has_alpha((GtkGLArea*)({* id *}), (gboolean)({* property.value *}))"} },
    ["has-depth-buffer"]   = {__type__="gboolean"      ,__default__ = "FALSE" , __gencode__ = {"gtk_gl_area_set_has_depth_buffer((GtkGLArea*)({* id *}), (gboolean)({* property.value *}))"} },
    ["has-stencil-buffer"] = {__type__="gboolean"      ,__default__ = "FALSE" , __gencode__ = {"gtk_gl_area_set_has_stencil_buffer((GtkGLArea*)({* id *}), (gboolean)({* property.value *}))"} },
    ["use-es"]             = {__type__="gboolean"      ,__default__ = "FALSE" , __gencode__ = {"gtk_gl_area_set_use_es((GtkGLArea*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk324.GtkWidget,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkGesture
Gtk324.GtkGesture = {
  class = "GtkGesture", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    begin                      = {ret_type = "void", params = {type = {"GtkGesture*", "GdkEventSequence*"}, name ={"gesture", "sequence"}} }, 
    cancel                     = {ret_type = "void", params = {type = {"GtkGesture*", "GdkEventSequence*"}, name ={"gesture", "sequence"}} }, 
    ['end']                    = {ret_type = "void", params = {type = {"GtkGesture*", "GdkEventSequence*"}, name ={"gesture", "sequence"}} }, 
    ['sequence-state-changed'] = {ret_type = "void", params = {type = {"GtkGesture*", "GdkEventSequence*", "GtkEventSequenceState"}, name ={"gesture", "sequence", "state"}} }, 
    update                     = {ret_type = "void", params = {type = {"GtkGesture*", "GdkEventSequence*"}, name ={"gesture", "sequence"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["n-points"] = {__type__="guint"      ,__default__ = "1" ,rwflags="rw" },
    window       = {__type__="GdkWindow*"                    , __gencode__ = {"gtk_gesture_set_window((GtkGesture*)({* id *}), (GdkWindow*)({* property.value *}))"} },
  },
  parent = Gtk324.GtkEventController,
};

---------------------  GtkHSV
Gtk324.GtkHSV = {
  class = "GtkHSV", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_hsv_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    changed = {"void", {"GtkHSV*"}, {"hsv"} }, 
    move    = {"void", {"GtkHSV*", "GtkDirectionType"}, {"hsv", "type"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed = {ret_type = "void", params = {type = {"GtkHSV*"}, name ={"hsv"}} }, 
    move    = {ret_type = "void", params = {type = {"GtkHSV*", "GtkDirectionType"}, name ={"hsv", "type"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkWidget,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkIMContextSimple
Gtk324.GtkIMContextSimple = {
  class = "GtkIMContextSimple", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_im_context_simple_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkIMContext,
};

---------------------  GtkIMMulticontext
Gtk324.GtkIMMulticontext = {
  class = "GtkIMMulticontext", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_im_multicontext_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkIMContext,
};

---------------------  GtkInvisible
Gtk324.GtkInvisible = {
  class = "GtkInvisible", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_invisible_new()", 
            params = { type = {}, name = {} } },
    new_for_screen = { gencode = "gtk_invisible_new_for_screen((GdkScreen*)({* this.screen.value *}))", 
            params = { type = {"GdkScreen*"}, 
                       name = {"screen"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    screen = {__type__="GdkScreen*" , __gencode__ = {"gtk_invisible_set_screen((GtkInvisible*)({* id *}), (GdkScreen*)({* property.value *}))"} },
  },
  parent = Gtk324.GtkWidget,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkLevelBar
Gtk324.GtkLevelBar = {
  class = "GtkLevelBar", 
  constructor = { 
    -- 名称[- ==> _], 
    new              = { gencode = "gtk_level_bar_new()", 
            params = { type = {}, name = {} } },
    new_for_interval = { gencode = "gtk_level_bar_new_for_interval((gdouble)({* this['min-value']value *}), (gdouble)({* this['max-value'].value *}))", 
            params = { type = {"gdouble", "gdouble"}, 
                       name = {"min-value", "max-value"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    offset_changed = {"void", {"GtkLevelBar*", "const gchar*"}, {"self", "name"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['offset-changed'] = {ret_type = "void", params = {type = {"GtkLevelBar*", "gchar*"}, name ={"levelbar", "name"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    inverted      = {__type__="gboolean"        ,__default__ = "FALSE"                         , __gencode__ = {"gtk_level_bar_set_inverted((GtkLevelBar*)({* id *}), (gboolean)({* property.value *}))"} },
    ["max-value"] = {__type__="gdouble"         ,__default__ = "1"                             , __gencode__ = {"gtk_level_bar_set_max_value((GtkLevelBar*)({* id *}), (gdouble)({* property.value *}))"} },
    ["min-value"] = {__type__="gdouble"         ,__default__ = "0"                             , __gencode__ = {"gtk_level_bar_set_min_value((GtkLevelBar*)({* id *}), (gdouble)({* property.value *}))"} },
    mode          = {__type__="GtkLevelBarMode" ,__default__ = "GTK_LEVEL_BAR_MODE_CONTINUOUS" , __gencode__ = {"gtk_level_bar_set_mode((GtkLevelBar*)({* id *}), (GtkLevelBarMode)({* property.value *}))"} },
    value         = {__type__="gdouble"         ,__default__ = "0"                             , __gencode__ = {"gtk_level_bar_set_value((GtkLevelBar*)({* id *}), (gdouble)({* property.value *}))"} },
  },
  parent = Gtk324.GtkWidget,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkMisc
Gtk324.GtkMisc = {
  class = "GtkMisc", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    xalign = {__type__="gfloat" ,__default__ = "0.5" ,rwflags="rw" },
    xpad   = {__type__="gint"   ,__default__ = "0"   ,rwflags="rw" },
    yalign = {__type__="gfloat" ,__default__ = "0.5" ,rwflags="rw" },
    ypad   = {__type__="gint"   ,__default__ = "0"   ,rwflags="rw" },
  },
  parent = Gtk324.GtkWidget,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkPadController
Gtk324.GtkPadController = {
  class = "GtkPadController", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_pad_controller_new((GtkWindow*)({* this.window.value *}), (GActionGroup*)({* this.group.value *}), (GdkDevice*)({* this.pad.value *}))", 
            params = { type = {"GdkDevice*"}, 
                       name = {"pad"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["action-group"] = {__type__="GActionGroup*" ,rwflags="rw" },
    pad              = {__type__="GdkDevice*"    ,rwflags="rw" },
  },
  parent = Gtk324.GtkEventController,
};

---------------------  GtkProgressBar
Gtk324.GtkProgressBar = {
  class = "GtkProgressBar", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_progress_bar_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ellipsize      = {__type__="PangoEllipsizeMode" ,__default__ = "PANGO_ELLIPSIZE_NONE" , __gencode__ = {"gtk_progress_bar_set_ellipsize((GtkProgressBar*)({* id *}), (PangoEllipsizeMode)({* property.value *}))"} },
    fraction       = {__type__="gdouble"            ,__default__ = "0"                    , __gencode__ = {"gtk_progress_bar_set_fraction((GtkProgressBar*)({* id *}), (gdouble)({* property.value *}))"} },
    inverted       = {__type__="gboolean"           ,__default__ = "FALSE"                , __gencode__ = {"gtk_progress_bar_set_inverted((GtkProgressBar*)({* id *}), (gboolean)({* property.value *}))"} },
    ["pulse-step"] = {__type__="gdouble"            ,__default__ = "0.1"                  , __gencode__ = {"gtk_progress_bar_set_pulse_step((GtkProgressBar*)({* id *}), (gdouble)({* property.value *}))"} },
    ["show-text"]  = {__type__="gboolean"           ,__default__ = "FALSE"                , __gencode__ = {"gtk_progress_bar_set_show_text((GtkProgressBar*)({* id *}), (gboolean)({* property.value *}))"} },
    text           = {__type__="gchar*"             ,__default__ = "NULL"                 , __gencode__ = {"gtk_progress_bar_set_text((GtkProgressBar*)({* id *}), (const gchar*)({* property.value *}))"} },
  },
  parent = Gtk324.GtkWidget,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkRange
Gtk324.GtkRange = {
  class = "GtkRange", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    adjust_bounds          = {"void"    , {"GtkRange*", "gdouble"}, {"range", "new_value"} }, 
    change_value           = {"gboolean", {"GtkRange*", "GtkScrollType", "gdouble"}, {"range", "scroll", "new_value"} }, 
    get_range_border       = {"void"    , {"GtkRange*", "GtkBorder*"}, {"range", "border_"} }, 
    get_range_size_request = {"void"    , {"GtkRange*", "GtkOrientation", "gint*", "gint*"}, {"range", "orientation", "minimum", "natural"} }, 
    move_slider            = {"void"    , {"GtkRange*", "GtkScrollType"}, {"range", "scroll"} }, 
    value_changed          = {"void"    , {"GtkRange*"}, {"range"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['adjust-bounds'] = {ret_type = "void"    , params = {type = {"GtkRange*", "gdouble"}, name ={"range", "value"}} }, 
    ['change-value']  = {ret_type = "gboolean", params = {type = {"GtkRange*", "GtkScrollType", "gdouble"}, name ={"range", "scroll", "value"}} }, 
    ['move-slider']   = {ret_type = "void"    , params = {type = {"GtkRange*", "GtkScrollType"}, name ={"range", "step"}} }, 
    ['value-changed'] = {ret_type = "void"    , params = {type = {"GtkRange*"}, name ={"range"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    adjustment                    = {__type__="GtkAdjustment*"                                           , __gencode__ = {"gtk_range_set_adjustment((GtkRange*)({* id *}), (GtkAdjustment*)({* property.value *}))"},__construct__= 1 },
    ["fill-level"]                = {__type__="gdouble"            ,__default__ = "1.79769e+308"         , __gencode__ = {"gtk_range_set_fill_level((GtkRange*)({* id *}), (gdouble)({* property.value *}))"} },
    inverted                      = {__type__="gboolean"           ,__default__ = "FALSE"                , __gencode__ = {"gtk_range_set_inverted((GtkRange*)({* id *}), (gboolean)({* property.value *}))"} },
    ["lower-stepper-sensitivity"] = {__type__="GtkSensitivityType" ,__default__ = "GTK_SENSITIVITY_AUTO" , __gencode__ = {"gtk_range_set_lower_stepper_sensitivity((GtkRange*)({* id *}), (GtkSensitivityType)({* property.value *}))"} },
    ["restrict-to-fill-level"]    = {__type__="gboolean"           ,__default__ = "TRUE"                 , __gencode__ = {"gtk_range_set_restrict_to_fill_level((GtkRange*)({* id *}), (gboolean)({* property.value *}))"} },
    ["round-digits"]              = {__type__="gint"               ,__default__ = "-1"                   , __gencode__ = {"gtk_range_set_round_digits((GtkRange*)({* id *}), (gint)({* property.value *}))"} },
    ["show-fill-level"]           = {__type__="gboolean"           ,__default__ = "FALSE"                , __gencode__ = {"gtk_range_set_show_fill_level((GtkRange*)({* id *}), (gboolean)({* property.value *}))"} },
    ["upper-stepper-sensitivity"] = {__type__="GtkSensitivityType" ,__default__ = "GTK_SENSITIVITY_AUTO" , __gencode__ = {"gtk_range_set_upper_stepper_sensitivity((GtkRange*)({* id *}), (GtkSensitivityType)({* property.value *}))"} },
  },
  parent = Gtk324.GtkWidget,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkRecentAction
Gtk324.GtkRecentAction = {
  class = "GtkRecentAction", 
  constructor = { 
    -- 名称[- ==> _], 
    new             = { gencode = "gtk_recent_action_new((const gchar*)({* this.name.value *}), (const gchar*)({* this.label.value *}), (const gchar*)({* this.tooltip.value *}), (const gchar*)({* this['stock-id'].value *}))", 
            params = { type = {"const gchar*", "const gchar*", "const gchar*", "const gchar*"}, 
                       name = {"name", "label", "tooltip", "stock-id"} } },
    new_for_manager = { gencode = "gtk_recent_action_new_for_manager((const gchar*)({* this.name.value *}), (const gchar*)({* this.label.value *}), (const gchar*)({* this.tooltip.value *}), (const gchar*)({* this['stock-id'].value *}), (GtkRecentManager*)({* this.manager.value *}))", 
            params = { type = {"const gchar*", "const gchar*", "const gchar*", "const gchar*"}, 
                       name = {"name", "label", "tooltip", "stock-id"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["show-numbers"] = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_recent_action_set_show_numbers((GtkRecentAction*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk324.GtkAction,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkRecentChooser}, 
};

---------------------  GtkSeparator
Gtk324.GtkSeparator = {
  class = "GtkSeparator", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_separator_new((GtkOrientation)({* this.orientation.value *}))", 
            params = { type = {"GtkOrientation"}, 
                       name = {"orientation"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkWidget,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkSpinner
Gtk324.GtkSpinner = {
  class = "GtkSpinner", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_spinner_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    active = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
  },
  parent = Gtk324.GtkWidget,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkSwitch
Gtk324.GtkSwitch = {
  class = "GtkSwitch", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_switch_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate  = {"void"    , {"GtkSwitch*"}, {"sw"} }, 
    state_set = {"gboolean", {"GtkSwitch*", "gboolean"}, {"sw", "state"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate      = {ret_type = "void"    , params = {type = {"GtkSwitch*"}, name ={"sw"}} }, 
    ['state-set'] = {ret_type = "gboolean", params = {type = {"GtkSwitch*", "gboolean"}, name ={"switch", "state"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    active = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_switch_set_active((GtkSwitch*)({* id *}), (gboolean)({* property.value *}))"} },
    state  = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_switch_set_state((GtkSwitch*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk324.GtkWidget,
  implement = {Gtk324.GtkActionable, Gtk324.GtkActivatable, Gtk324.GtkBuildable}, 
};

---------------------  GtkToggleAction
Gtk324.GtkToggleAction = {
  class = "GtkToggleAction", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_toggle_action_new((const gchar*)({* this.name.value *}), (const gchar*)({* this.label.value *}), (const gchar*)({* this.tooltip.value *}), (const gchar*)({* this['stock-id'].value *}))", 
            params = { type = {"const gchar*", "const gchar*", "const gchar*", "const gchar*"}, 
                       name = {"name", "label", "tooltip", "stock-id"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    toggled = {"void", {"GtkToggleAction*"}, {"action"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    toggled = {ret_type = "void", params = {type = {"GtkToggleAction*"}, name ={"action"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    active            = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_toggle_action_set_active((GtkToggleAction*)({* id *}), (gboolean)({* property.value *}))"} },
    ["draw-as-radio"] = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_toggle_action_set_draw_as_radio((GtkToggleAction*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk324.GtkAction,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkWidgetAccessible
Gtk324.GtkWidgetAccessible = {
  class = "GtkWidgetAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkAccessible,
};

---------------------  GtkArrow
Gtk324.GtkArrow = {
  class = "GtkArrow", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_arrow_new((GtkArrowType)({* this['arrow-type']value *}), (GtkShadowType)({* this['shadow-type'].value *}))", 
            params = { type = {"GtkArrowType", "GtkShadowType"}, 
                       name = {"arrow-type", "shadow-type"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["arrow-type"]  = {__type__="GtkArrowType"  ,__default__ = "GTK_ARROW_RIGHT" ,rwflags="rw" },
    ["shadow-type"] = {__type__="GtkShadowType" ,__default__ = "GTK_SHADOW_OUT"  ,rwflags="rw" },
  },
  parent = Gtk324.GtkMisc,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkArrowAccessible
Gtk324.GtkArrowAccessible = {
  class = "GtkArrowAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkWidgetAccessible,
};

---------------------  GtkBin
Gtk324.GtkBin = {
  class = "GtkBin", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkContainer,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkBox
Gtk324.GtkBox = {
  class = "GtkBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_box_new((GtkOrientation)({* this.orientation.value *}), (gint)({* this.spacing.value *}))", 
            params = { type = {"GtkOrientation", "gint"}, 
                       name = {"orientation", "spacing"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["baseline-position"] = {__type__="GtkBaselinePosition" ,__default__ = "GTK_BASELINE_POSITION_CENTER" , __gencode__ = {"gtk_box_set_baseline_position((GtkBox*)({* id *}), (GtkBaselinePosition)({* property.value *}))"} },
    homogeneous           = {__type__="gboolean"            ,__default__ = "FALSE"                        , __gencode__ = {"gtk_box_set_homogeneous((GtkBox*)({* id *}), (gboolean)({* property.value *}))"} },
    spacing               = {__type__="gint"                ,__default__ = "0"                            , __gencode__ = {"gtk_box_set_spacing((GtkBox*)({* id *}), (gint)({* property.value *}))"} },
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    expand        = {__type__="gboolean"    ,__default__ = "FALSE" },
    fill          = {__type__="gboolean"    ,__default__ = "TRUE" },
    ["pack-type"] = {__type__="GtkPackType" ,__default__ = "GTK_PACK_START" },
    padding       = {__type__="guint"       ,__default__ = "0" },
    position      = {__type__="gint"        ,__default__ = "0" },
  },
  parent = Gtk324.GtkContainer,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkCellRendererAccel
Gtk324.GtkCellRendererAccel = {
  class = "GtkCellRendererAccel", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_cell_renderer_accel_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    accel_cleared = {"void", {"GtkCellRendererAccel*", "const gchar*"}, {"accel", "path_string"} }, 
    accel_edited  = {"void", {"GtkCellRendererAccel*", "const gchar*", "guint", "GdkModifierType", "guint"}, {"accel", "path_string", "accel_key", "accel_mods", "hardware_keycode"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['accel-cleared'] = {ret_type = "void", params = {type = {"GtkCellRendererAccel*", "gchar*"}, name ={"cellrendereraccel", "path_string"}} }, 
    ['accel-edited']  = {ret_type = "void", params = {type = {"GtkCellRendererAccel*", "gchar*", "guint", "GdkModifierType*", "guint"}, name ={"cellrendereraccel", "path_string", "accel_key", "accel_mods", "hardware_keycode"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["accel-key"]  = {__type__="guint"                    ,__default__ = "0"                                ,rwflags="rw" },
    ["accel-mode"] = {__type__="GtkCellRendererAccelMode" ,__default__ = "GTK_CELL_RENDERER_ACCEL_MODE_GTK" ,rwflags="rw" },
    ["accel-mods"] = {__type__="GdkModifierType*"                                                           ,rwflags="rw" },
    keycode        = {__type__="guint"                    ,__default__ = "0"                                ,rwflags="rw" },
  },
  parent = Gtk324.GtkCellRendererText,
};

---------------------  GtkCellRendererCombo
Gtk324.GtkCellRendererCombo = {
  class = "GtkCellRendererCombo", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_cell_renderer_combo_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed = {ret_type = "void", params = {type = {"GtkCellRendererCombo*", "gchar*", "GtkTreeIter*"}, name ={"cellrenderercombo", "path_string", "new_iter"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["has-entry"]   = {__type__="gboolean"      ,__default__ = "TRUE" ,rwflags="rw" },
    model           = {__type__="GtkTreeModel*"                       ,rwflags="rw" },
    ["text-column"] = {__type__="gint"          ,__default__ = "-1"   ,rwflags="rw" },
  },
  parent = Gtk324.GtkCellRendererText,
};

---------------------  GtkCellRendererSpin
Gtk324.GtkCellRendererSpin = {
  class = "GtkCellRendererSpin", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_cell_renderer_spin_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    adjustment     = {__type__="GtkAdjustment*"                    ,rwflags="rw" },
    ["climb-rate"] = {__type__="gdouble"        ,__default__ = "0" ,rwflags="rw" },
    digits         = {__type__="guint"          ,__default__ = "0" ,rwflags="rw" },
  },
  parent = Gtk324.GtkCellRendererText,
};

---------------------  GtkContainerAccessible
Gtk324.GtkContainerAccessible = {
  class = "GtkContainerAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkWidgetAccessible,
};

---------------------  GtkContainerCellAccessible
Gtk324.GtkContainerCellAccessible = {
  class = "GtkContainerCellAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_container_cell_accessible_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkCellAccessible,
};

---------------------  GtkEntryAccessible
Gtk324.GtkEntryAccessible = {
  class = "GtkEntryAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkWidgetAccessible,
};

---------------------  GtkFixed
Gtk324.GtkFixed = {
  class = "GtkFixed", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_fixed_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    x = {__type__="gint" ,__default__ = "0" },
    y = {__type__="gint" ,__default__ = "0" },
  },
  parent = Gtk324.GtkContainer,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkFlowBox
Gtk324.GtkFlowBox = {
  class = "GtkFlowBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_flow_box_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate_cursor_child     = {"void"    , {"GtkFlowBox*"}, {"box"} }, 
    child_activated           = {"void"    , {"GtkFlowBox*", "GtkFlowBoxChild*"}, {"box", "child"} }, 
    move_cursor               = {"gboolean", {"GtkFlowBox*", "GtkMovementStep", "gint"}, {"box", "step", "count"} }, 
    select_all                = {"void"    , {"GtkFlowBox*"}, {"box"} }, 
    selected_children_changed = {"void"    , {"GtkFlowBox*"}, {"box"} }, 
    toggle_cursor_child       = {"void"    , {"GtkFlowBox*"}, {"box"} }, 
    unselect_all              = {"void"    , {"GtkFlowBox*"}, {"box"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['activate-cursor-child']     = {ret_type = "void"    , params = {type = {"GtkFlowBox*"}, name ={"flowbox"}} }, 
    ['child-activated']           = {ret_type = "void"    , params = {type = {"GtkFlowBox*", "GtkFlowBoxChild*"}, name ={"flowbox", "child"}} }, 
    ['move-cursor']               = {ret_type = "gboolean", params = {type = {"GtkFlowBox*", "GtkMovementStep", "gint"}, name ={"flowbox", "step", "count"}} }, 
    ['select-all']                = {ret_type = "void"    , params = {type = {"GtkFlowBox*"}, name ={"flowbox"}} }, 
    ['selected-children-changed'] = {ret_type = "void"    , params = {type = {"GtkFlowBox*"}, name ={"flowbox"}} }, 
    ['toggle-cursor-child']       = {ret_type = "void"    , params = {type = {"GtkFlowBox*"}, name ={"flowbox"}} }, 
    ['unselect-all']              = {ret_type = "void"    , params = {type = {"GtkFlowBox*"}, name ={"flowbox"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["activate-on-single-click"] = {__type__="gboolean"         ,__default__ = "TRUE"                 , __gencode__ = {"gtk_flow_box_set_activate_on_single_click((GtkFlowBox*)({* id *}), (gboolean)({* property.value *}))"} },
    ["column-spacing"]           = {__type__="guint"            ,__default__ = "0"                    , __gencode__ = {"gtk_flow_box_set_column_spacing((GtkFlowBox*)({* id *}), (guint)({* property.value *}))"} },
    homogeneous                  = {__type__="gboolean"         ,__default__ = "FALSE"                , __gencode__ = {"gtk_flow_box_set_homogeneous((GtkFlowBox*)({* id *}), (gboolean)({* property.value *}))"} },
    ["max-children-per-line"]    = {__type__="guint"            ,__default__ = "7"                    , __gencode__ = {"gtk_flow_box_set_max_children_per_line((GtkFlowBox*)({* id *}), (guint)({* property.value *}))"} },
    ["min-children-per-line"]    = {__type__="guint"            ,__default__ = "0"                    , __gencode__ = {"gtk_flow_box_set_min_children_per_line((GtkFlowBox*)({* id *}), (guint)({* property.value *}))"} },
    ["row-spacing"]              = {__type__="guint"            ,__default__ = "0"                    , __gencode__ = {"gtk_flow_box_set_row_spacing((GtkFlowBox*)({* id *}), (guint)({* property.value *}))"} },
    ["selection-mode"]           = {__type__="GtkSelectionMode" ,__default__ = "GTK_SELECTION_SINGLE" , __gencode__ = {"gtk_flow_box_set_selection_mode((GtkFlowBox*)({* id *}), (GtkSelectionMode)({* property.value *}))"} },
  },
  parent = Gtk324.GtkContainer,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkGestureRotate
Gtk324.GtkGestureRotate = {
  class = "GtkGestureRotate", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_gesture_rotate_new((GtkWidget*)({* this.widget.value *}))", 
            params = { type = {"GtkWidget*"}, 
                       name = {"widget"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['angle-changed'] = {ret_type = "void", params = {type = {"GtkGestureRotate*", "gdouble", "gdouble"}, name ={"gesturerotate", "angle", "angle_delta"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkGesture,
};

---------------------  GtkGestureSingle
Gtk324.GtkGestureSingle = {
  class = "GtkGestureSingle", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    button         = {__type__="guint"    ,__default__ = "1"     , __gencode__ = {"gtk_gesture_single_set_button((GtkGestureSingle*)({* id *}), (guint)({* property.value *}))"} },
    exclusive      = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_gesture_single_set_exclusive((GtkGestureSingle*)({* id *}), (gboolean)({* property.value *}))"} },
    ["touch-only"] = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_gesture_single_set_touch_only((GtkGestureSingle*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk324.GtkGesture,
};

---------------------  GtkGestureZoom
Gtk324.GtkGestureZoom = {
  class = "GtkGestureZoom", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_gesture_zoom_new((GtkWidget*)({* this.widget.value *}))", 
            params = { type = {"GtkWidget*"}, 
                       name = {"widget"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['scale-changed'] = {ret_type = "void", params = {type = {"GtkGestureZoom*", "gdouble"}, name ={"gesturezoom", "scale"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkGesture,
};

---------------------  GtkGrid
Gtk324.GtkGrid = {
  class = "GtkGrid", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_grid_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["baseline-row"]       = {__type__="gint"     ,__default__ = "0"     , __gencode__ = {"gtk_grid_set_baseline_row((GtkGrid*)({* id *}), (gint)({* property.value *}))"} },
    ["column-homogeneous"] = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_grid_set_column_homogeneous((GtkGrid*)({* id *}), (gboolean)({* property.value *}))"} },
    ["column-spacing"]     = {__type__="gint"     ,__default__ = "0"     , __gencode__ = {"gtk_grid_set_column_spacing((GtkGrid*)({* id *}), (guint)({* property.value *}))"} },
    ["row-homogeneous"]    = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_grid_set_row_homogeneous((GtkGrid*)({* id *}), (gboolean)({* property.value *}))"} },
    ["row-spacing"]        = {__type__="gint"     ,__default__ = "0"     , __gencode__ = {"gtk_grid_set_row_spacing((GtkGrid*)({* id *}), (guint)({* property.value *}))"} },
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    height          = {__type__="gint" ,__default__ = "1" },
    ["left-attach"] = {__type__="gint" ,__default__ = "0" },
    ["top-attach"]  = {__type__="gint" ,__default__ = "0" },
    width           = {__type__="gint" ,__default__ = "1" },
  },
  parent = Gtk324.GtkContainer,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkHSeparator
Gtk324.GtkHSeparator = {
  class = "GtkHSeparator", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_hseparator_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkSeparator,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkHeaderBar
Gtk324.GtkHeaderBar = {
  class = "GtkHeaderBar", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_header_bar_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["custom-title"]          = {__type__="GtkWidget*"                        , __gencode__ = {"gtk_header_bar_set_custom_title((GtkHeaderBar*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["decoration-layout"]     = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_header_bar_set_decoration_layout((GtkHeaderBar*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["decoration-layout-set"] = {__type__="gboolean"   ,__default__ = "FALSE" ,rwflags="rw" },
    ["has-subtitle"]          = {__type__="gboolean"   ,__default__ = "TRUE"  , __gencode__ = {"gtk_header_bar_set_has_subtitle((GtkHeaderBar*)({* id *}), (gboolean)({* property.value *}))"} },
    ["show-close-button"]     = {__type__="gboolean"   ,__default__ = "FALSE" , __gencode__ = {"gtk_header_bar_set_show_close_button((GtkHeaderBar*)({* id *}), (gboolean)({* property.value *}))"} },
    spacing                   = {__type__="gint"       ,__default__ = "6"     ,rwflags="rw" },
    subtitle                  = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_header_bar_set_subtitle((GtkHeaderBar*)({* id *}), (const gchar*)({* property.value *}))"} },
    title                     = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_header_bar_set_title((GtkHeaderBar*)({* id *}), (const gchar*)({* property.value *}))"} },
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    ["pack-type"] = {__type__="GtkPackType" ,__default__ = "GTK_PACK_START" },
    position      = {__type__="gint"        ,__default__ = "0" },
  },
  parent = Gtk324.GtkContainer,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkIconView
Gtk324.GtkIconView = {
  class = "GtkIconView", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_icon_view_new()", 
            params = { type = {}, name = {} } },
    new_with_area  = { gencode = "gtk_icon_view_new_with_area((GtkCellArea*)({* this.area.value *}))", 
            params = { type = {}, name = {} } },
    new_with_model = { gencode = "gtk_icon_view_new_with_model((GtkTreeModel*)({* this.model.value *}))", 
            params = { type = {"GtkTreeModel*"}, 
                       name = {"model"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate_cursor_item = {"gboolean", {"GtkIconView*"}, {"icon_view"} }, 
    item_activated       = {"void"    , {"GtkIconView*", "GtkTreePath*"}, {"icon_view", "path"} }, 
    move_cursor          = {"gboolean", {"GtkIconView*", "GtkMovementStep", "gint"}, {"icon_view", "step", "count"} }, 
    select_all           = {"void"    , {"GtkIconView*"}, {"icon_view"} }, 
    select_cursor_item   = {"void"    , {"GtkIconView*"}, {"icon_view"} }, 
    selection_changed    = {"void"    , {"GtkIconView*"}, {"icon_view"} }, 
    toggle_cursor_item   = {"void"    , {"GtkIconView*"}, {"icon_view"} }, 
    unselect_all         = {"void"    , {"GtkIconView*"}, {"icon_view"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['activate-cursor-item'] = {ret_type = "gboolean", params = {type = {"GtkIconView*"}, name ={"iconview"}} }, 
    ['item-activated']       = {ret_type = "void"    , params = {type = {"GtkIconView*", "GtkTreePath*"}, name ={"iconview", "path"}} }, 
    ['move-cursor']          = {ret_type = "gboolean", params = {type = {"GtkIconView*", "GtkMovementStep", "gint"}, name ={"iconview", "step", "count"}} }, 
    ['select-all']           = {ret_type = "void"    , params = {type = {"GtkIconView*"}, name ={"iconview"}} }, 
    ['select-cursor-item']   = {ret_type = "void"    , params = {type = {"GtkIconView*"}, name ={"iconview"}} }, 
    ['selection-changed']    = {ret_type = "void"    , params = {type = {"GtkIconView*"}, name ={"iconview"}} }, 
    ['toggle-cursor-item']   = {ret_type = "void"    , params = {type = {"GtkIconView*"}, name ={"iconview"}} }, 
    ['unselect-all']         = {ret_type = "void"    , params = {type = {"GtkIconView*"}, name ={"iconview"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["activate-on-single-click"] = {__type__="gboolean"         ,__default__ = "FALSE"                    , __gencode__ = {"gtk_icon_view_set_activate_on_single_click((GtkIconView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["cell-area"]                = {__type__="GtkCellArea*"                                               ,rwflags="rw" },
    ["column-spacing"]           = {__type__="gint"             ,__default__ = "6"                        , __gencode__ = {"gtk_icon_view_set_column_spacing((GtkIconView*)({* id *}), (gint)({* property.value *}))"} },
    columns                      = {__type__="gint"             ,__default__ = "-1"                       , __gencode__ = {"gtk_icon_view_set_columns((GtkIconView*)({* id *}), (gint)({* property.value *}))"} },
    ["item-orientation"]         = {__type__="GtkOrientation"   ,__default__ = "GTK_ORIENTATION_VERTICAL" , __gencode__ = {"gtk_icon_view_set_item_orientation((GtkIconView*)({* id *}), (GtkOrientation)({* property.value *}))"} },
    ["item-padding"]             = {__type__="gint"             ,__default__ = "6"                        , __gencode__ = {"gtk_icon_view_set_item_padding((GtkIconView*)({* id *}), (gint)({* property.value *}))"} },
    ["item-width"]               = {__type__="gint"             ,__default__ = "-1"                       , __gencode__ = {"gtk_icon_view_set_item_width((GtkIconView*)({* id *}), (gint)({* property.value *}))"} },
    margin                       = {__type__="gint"             ,__default__ = "6"                        , __gencode__ = {"gtk_icon_view_set_margin((GtkIconView*)({* id *}), (gint)({* property.value *}))"} },
    ["markup-column"]            = {__type__="gint"             ,__default__ = "-1"                       , __gencode__ = {"gtk_icon_view_set_markup_column((GtkIconView*)({* id *}), (gint)({* property.value *}))"} },
    model                        = {__type__="GtkTreeModel*"                                              , __gencode__ = {"gtk_icon_view_set_model((GtkIconView*)({* id *}), (GtkTreeModel*)({* property.value *}))"} },
    ["pixbuf-column"]            = {__type__="gint"             ,__default__ = "-1"                       , __gencode__ = {"gtk_icon_view_set_pixbuf_column((GtkIconView*)({* id *}), (gint)({* property.value *}))"} },
    reorderable                  = {__type__="gboolean"         ,__default__ = "FALSE"                    , __gencode__ = {"gtk_icon_view_set_reorderable((GtkIconView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["row-spacing"]              = {__type__="gint"             ,__default__ = "6"                        , __gencode__ = {"gtk_icon_view_set_row_spacing((GtkIconView*)({* id *}), (gint)({* property.value *}))"} },
    ["selection-mode"]           = {__type__="GtkSelectionMode" ,__default__ = "GTK_SELECTION_SINGLE"     , __gencode__ = {"gtk_icon_view_set_selection_mode((GtkIconView*)({* id *}), (GtkSelectionMode)({* property.value *}))"} },
    spacing                      = {__type__="gint"             ,__default__ = "0"                        , __gencode__ = {"gtk_icon_view_set_spacing((GtkIconView*)({* id *}), (gint)({* property.value *}))"} },
    ["text-column"]              = {__type__="gint"             ,__default__ = "-1"                       , __gencode__ = {"gtk_icon_view_set_text_column((GtkIconView*)({* id *}), (gint)({* property.value *}))"} },
    ["tooltip-column"]           = {__type__="gint"             ,__default__ = "-1"                       , __gencode__ = {"gtk_icon_view_set_tooltip_column((GtkIconView*)({* id *}), (gint)({* property.value *}))"} },
  },
  parent = Gtk324.GtkContainer,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkCellLayout, Gtk324.GtkScrollable}, 
};

---------------------  GtkImage
Gtk324.GtkImage = {
  class = "GtkImage", 
  constructor = { 
    -- 名称[- ==> _], 
    new                = { gencode = "gtk_image_new()", 
            params = { type = {}, name = {} } },
    new_from_animation = { gencode = "gtk_image_new_from_animation((GdkPixbufAnimation*)({* this.animation.value *}))", 
            params = { type = {}, name = {} } },
    new_from_file      = { gencode = "gtk_image_new_from_file((const gchar*)({* this.filename.value *}))", 
            params = { type = {}, name = {} } },
    new_from_gicon     = { gencode = "gtk_image_new_from_gicon((GIcon*)({* this.icon.value *}), (GtkIconSize)({* this.size.value *}))", 
            params = { type = {}, name = {} } },
    new_from_icon_name = { gencode = "gtk_image_new_from_icon_name((const gchar*)({* this['icon-name']value *}), (GtkIconSize)({* this.size.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"icon-name"} } },
    new_from_icon_set  = { gencode = "gtk_image_new_from_icon_set((GtkIconSet*)({* this['icon-set']value *}), (GtkIconSize)({* this.size.value *}))", 
            params = { type = {"GtkIconSet*"}, 
                       name = {"icon-set"} } },
    new_from_pixbuf    = { gencode = "gtk_image_new_from_pixbuf((GdkPixbuf*)({* this.pixbuf.value *}))", 
            params = { type = {"GdkPixbuf*"}, 
                       name = {"pixbuf"} } },
    new_from_resource  = { gencode = "gtk_image_new_from_resource((const gchar*)({* this.resource_path.value *}))", 
            params = { type = {}, name = {} } },
    new_from_stock     = { gencode = "gtk_image_new_from_stock((const gchar*)({* this.stock_id.value *}), (GtkIconSize)({* this.size.value *}))", 
            params = { type = {}, name = {} } },
    new_from_surface   = { gencode = "gtk_image_new_from_surface((cairo_surface_t*)({* this.surface.value *}))", 
            params = { type = {"cairo_surface_t*"}, 
                       name = {"surface"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    file                 = {__type__="gchar*"              ,__default__ = "NULL"            , __gencode__ = {"gtk_image_set_from_file((GtkImage*)({* id *}), (const gchar*)({* property.value *}))"} },
    gicon                = {__type__="GIcon*"                                               , __gencode__ = {"gtk_image_set_from_gicon((GtkImage*)({* id *}), (GIcon*)({* property.value *}), (GtkIconSize)({* property.value *}))"} },
    ["icon-name"]        = {__type__="gchar*"              ,__default__ = "NULL"            , __gencode__ = {"gtk_image_set_from_icon_name((GtkImage*)({* id *}), (const gchar*)({* property.value *}), (GtkIconSize)({* property.value *}))"} },
    ["icon-set"]         = {__type__="GtkIconSet*"                                          , __gencode__ = {"gtk_image_set_from_icon_set((GtkImage*)({* id *}), (GtkIconSet*)({* property.value *}), (GtkIconSize)({* property.value *}))"} },
    ["icon-size"]        = {__type__="gint"                ,__default__ = "4"               ,rwflags="rw" },
    pixbuf               = {__type__="GdkPixbuf*"                                           , __gencode__ = {"gtk_image_set_from_pixbuf((GtkImage*)({* id *}), (GdkPixbuf*)({* property.value *}))"} },
    ["pixbuf-animation"] = {__type__="GdkPixbufAnimation*"                                  ,rwflags="rw" },
    ["pixel-size"]       = {__type__="gint"                ,__default__ = "-1"              , __gencode__ = {"gtk_image_set_pixel_size((GtkImage*)({* id *}), (gint)({* property.value *}))"} },
    resource             = {__type__="gchar*"              ,__default__ = "NULL"            , __gencode__ = {"gtk_image_set_from_resource((GtkImage*)({* id *}), (const gchar*)({* property.value *}))"} },
    stock                = {__type__="gchar*"              ,__default__ = "NULL"            , __gencode__ = {"gtk_image_set_from_stock((GtkImage*)({* id *}), (const gchar*)({* property.value *}), (GtkIconSize)({* property.value *}))"} },
    ["storage-type"]     = {__type__="GtkImageType"        ,__default__ = "GTK_IMAGE_EMPTY"  },
    surface              = {__type__="CairoSurface*"                                        , __gencode__ = {"gtk_image_set_from_surface((GtkImage*)({* id *}), (cairo_surface_t*)({* property.value *}))"} },
    ["use-fallback"]     = {__type__="gboolean"            ,__default__ = "FALSE"           ,rwflags="rw" },
  },
  parent = Gtk324.GtkMisc,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkImageAccessible
Gtk324.GtkImageAccessible = {
  class = "GtkImageAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkWidgetAccessible,
};

---------------------  GtkLabel
Gtk324.GtkLabel = {
  class = "GtkLabel", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_label_new((const gchar*)({* this.str.value *}))", 
            params = { type = {}, name = {} } },
    new_with_mnemonic = { gencode = "gtk_label_new_with_mnemonic((const gchar*)({* this.str.value *}))", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate_link  = {"gboolean", {"GtkLabel*", "const gchar*"}, {"label", "uri"} }, 
    copy_clipboard = {"void"    , {"GtkLabel*"}, {"label"} }, 
    move_cursor    = {"void"    , {"GtkLabel*", "GtkMovementStep", "gint", "gboolean"}, {"label", "step", "count", "extend_selection"} }, 
    populate_popup = {"void"    , {"GtkLabel*", "GtkMenu*"}, {"label", "menu"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['activate-current-link'] = {ret_type = "void"    , params = {type = {"GtkLabel*"}, name ={"label"}} }, 
    ['activate-link']         = {ret_type = "gboolean", params = {type = {"GtkLabel*", "gchar*"}, name ={"label", "uri"}} }, 
    ['copy-clipboard']        = {ret_type = "void"    , params = {type = {"GtkLabel*"}, name ={"label"}} }, 
    ['move-cursor']           = {ret_type = "void"    , params = {type = {"GtkLabel*", "GtkMovementStep", "gint", "gboolean"}, name ={"label", "step", "count", "extend_selection"}} }, 
    ['populate-popup']        = {ret_type = "void"    , params = {type = {"GtkLabel*", "GtkMenu*"}, name ={"label", "menu"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    angle                   = {__type__="gdouble"            ,__default__ = "0"                    , __gencode__ = {"gtk_label_set_angle((GtkLabel*)({* id *}), (gdouble)({* property.value *}))"} },
    attributes              = {__type__="PangoAttrList*"                                           , __gencode__ = {"gtk_label_set_attributes((GtkLabel*)({* id *}), (PangoAttrList*)({* property.value *}))"} },
    ["cursor-position"]     = {__type__="gint"               ,__default__ = "0"                     },
    ellipsize               = {__type__="PangoEllipsizeMode" ,__default__ = "PANGO_ELLIPSIZE_NONE" , __gencode__ = {"gtk_label_set_ellipsize((GtkLabel*)({* id *}), (PangoEllipsizeMode)({* property.value *}))"} },
    justify                 = {__type__="GtkJustification"   ,__default__ = "GTK_JUSTIFY_LEFT"     , __gencode__ = {"gtk_label_set_justify((GtkLabel*)({* id *}), (GtkJustification)({* property.value *}))"} },
    label                   = {__type__="gchar*"             ,__default__ = "\"\""                 , __gencode__ = {"gtk_label_set_label((GtkLabel*)({* id *}), (const gchar*)({* property.value *}))"} },
    lines                   = {__type__="gint"               ,__default__ = "-1"                   , __gencode__ = {"gtk_label_set_lines((GtkLabel*)({* id *}), (gint)({* property.value *}))"} },
    ["max-width-chars"]     = {__type__="gint"               ,__default__ = "-1"                   , __gencode__ = {"gtk_label_set_max_width_chars((GtkLabel*)({* id *}), (gint)({* property.value *}))"} },
    ["mnemonic-keyval"]     = {__type__="guint"              ,__default__ = "16777215"              },
    ["mnemonic-widget"]     = {__type__="GtkWidget*"                                               , __gencode__ = {"gtk_label_set_mnemonic_widget((GtkLabel*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    pattern                 = {__type__="gchar*"             ,__default__ = "NULL"                 , __gencode__ = {"gtk_label_set_pattern((GtkLabel*)({* id *}), (const gchar*)({* property.value *}))"} },
    selectable              = {__type__="gboolean"           ,__default__ = "FALSE"                , __gencode__ = {"gtk_label_set_selectable((GtkLabel*)({* id *}), (gboolean)({* property.value *}))"} },
    ["selection-bound"]     = {__type__="gint"               ,__default__ = "0"                     },
    ["single-line-mode"]    = {__type__="gboolean"           ,__default__ = "FALSE"                , __gencode__ = {"gtk_label_set_single_line_mode((GtkLabel*)({* id *}), (gboolean)({* property.value *}))"} },
    ["track-visited-links"] = {__type__="gboolean"           ,__default__ = "TRUE"                 , __gencode__ = {"gtk_label_set_track_visited_links((GtkLabel*)({* id *}), (gboolean)({* property.value *}))"} },
    ["use-markup"]          = {__type__="gboolean"           ,__default__ = "FALSE"                , __gencode__ = {"gtk_label_set_use_markup((GtkLabel*)({* id *}), (gboolean)({* property.value *}))"} },
    ["use-underline"]       = {__type__="gboolean"           ,__default__ = "FALSE"                , __gencode__ = {"gtk_label_set_use_underline((GtkLabel*)({* id *}), (gboolean)({* property.value *}))"} },
    ["width-chars"]         = {__type__="gint"               ,__default__ = "-1"                   , __gencode__ = {"gtk_label_set_width_chars((GtkLabel*)({* id *}), (gint)({* property.value *}))"} },
    wrap                    = {__type__="gboolean"           ,__default__ = "FALSE"                ,rwflags="rw" },
    ["wrap-mode"]           = {__type__="PangoWrapMode"      ,__default__ = "PANGO_WRAP_WORD"      ,rwflags="rw" },
    xalign                  = {__type__="gfloat"             ,__default__ = "0.5"                  , __gencode__ = {"gtk_label_set_xalign((GtkLabel*)({* id *}), (gfloat)({* property.value *}))"} },
    yalign                  = {__type__="gfloat"             ,__default__ = "0.5"                  , __gencode__ = {"gtk_label_set_yalign((GtkLabel*)({* id *}), (gfloat)({* property.value *}))"} },
  },
  parent = Gtk324.GtkMisc,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkLabelAccessible
Gtk324.GtkLabelAccessible = {
  class = "GtkLabelAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkWidgetAccessible,
};

---------------------  GtkLayout
Gtk324.GtkLayout = {
  class = "GtkLayout", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_layout_new((GtkAdjustment*)({* this.hadjustment.value *}), (GtkAdjustment*)({* this.vadjustment.value *}))", 
            params = { type = {"GtkAdjustment*", "GtkAdjustment*"}, 
                       name = {"hadjustment", "vadjustment"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    height = {__type__="guint" ,__default__ = "100" ,rwflags="rw" },
    width  = {__type__="guint" ,__default__ = "100" ,rwflags="rw" },
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    x = {__type__="gint" ,__default__ = "0" },
    y = {__type__="gint" ,__default__ = "0" },
  },
  parent = Gtk324.GtkContainer,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkScrollable}, 
};

---------------------  GtkLevelBarAccessible
Gtk324.GtkLevelBarAccessible = {
  class = "GtkLevelBarAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkWidgetAccessible,
};

---------------------  GtkListBox
Gtk324.GtkListBox = {
  class = "GtkListBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_list_box_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate_cursor_row   = {"void", {"GtkListBox*"}, {"box"} }, 
    move_cursor           = {"void", {"GtkListBox*", "GtkMovementStep", "gint"}, {"box", "step", "count"} }, 
    row_activated         = {"void", {"GtkListBox*", "GtkListBoxRow*"}, {"box", "row"} }, 
    row_selected          = {"void", {"GtkListBox*", "GtkListBoxRow*"}, {"box", "row"} }, 
    select_all            = {"void", {"GtkListBox*"}, {"box"} }, 
    selected_rows_changed = {"void", {"GtkListBox*"}, {"box"} }, 
    toggle_cursor_row     = {"void", {"GtkListBox*"}, {"box"} }, 
    unselect_all          = {"void", {"GtkListBox*"}, {"box"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['activate-cursor-row']   = {ret_type = "void", params = {type = {"GtkListBox*"}, name ={"listbox"}} }, 
    ['move-cursor']           = {ret_type = "void", params = {type = {"GtkListBox*", "GtkMovementStep", "gint"}, name ={"listbox", "object", "p0"}} }, 
    ['row-activated']         = {ret_type = "void", params = {type = {"GtkListBox*", "GtkListBoxRow*"}, name ={"listbox", "row"}} }, 
    ['row-selected']          = {ret_type = "void", params = {type = {"GtkListBox*", "GtkListBoxRow*"}, name ={"listbox", "row"}} }, 
    ['select-all']            = {ret_type = "void", params = {type = {"GtkListBox*"}, name ={"listbox"}} }, 
    ['selected-rows-changed'] = {ret_type = "void", params = {type = {"GtkListBox*"}, name ={"listbox"}} }, 
    ['toggle-cursor-row']     = {ret_type = "void", params = {type = {"GtkListBox*"}, name ={"listbox"}} }, 
    ['unselect-all']          = {ret_type = "void", params = {type = {"GtkListBox*"}, name ={"listbox"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["activate-on-single-click"] = {__type__="gboolean"         ,__default__ = "TRUE"                 , __gencode__ = {"gtk_list_box_set_activate_on_single_click((GtkListBox*)({* id *}), (gboolean)({* property.value *}))"} },
    ["selection-mode"]           = {__type__="GtkSelectionMode" ,__default__ = "GTK_SELECTION_SINGLE" , __gencode__ = {"gtk_list_box_set_selection_mode((GtkListBox*)({* id *}), (GtkSelectionMode)({* property.value *}))"} },
  },
  parent = Gtk324.GtkContainer,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkMenuShell
Gtk324.GtkMenuShell = {
  class = "GtkMenuShell", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate_current = {"void"    , {"GtkMenuShell*", "gboolean"}, {"menu_shell", "force_hide"} }, 
    cancel           = {"void"    , {"GtkMenuShell*"}, {"menu_shell"} }, 
    deactivate       = {"void"    , {"GtkMenuShell*"}, {"menu_shell"} }, 
    get_popup_delay  = {"gint"    , {"GtkMenuShell*"}, {"menu_shell"} }, 
    insert           = {"void"    , {"GtkMenuShell*", "GtkWidget*", "gint"}, {"menu_shell", "child", "position"} }, 
    move_current     = {"void"    , {"GtkMenuShell*", "GtkMenuDirectionType"}, {"menu_shell", "direction"} }, 
    move_selected    = {"gboolean", {"GtkMenuShell*", "gint"}, {"menu_shell", "distance"} }, 
    select_item      = {"void"    , {"GtkMenuShell*", "GtkWidget*"}, {"menu_shell", "menu_item"} }, 
    selection_done   = {"void"    , {"GtkMenuShell*"}, {"menu_shell"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['activate-current'] = {ret_type = "void"    , params = {type = {"GtkMenuShell*", "gboolean"}, name ={"menushell", "force_hide"}} }, 
    cancel               = {ret_type = "void"    , params = {type = {"GtkMenuShell*"}, name ={"menu_shell"}} }, 
    ['cycle-focus']      = {ret_type = "void"    , params = {type = {"GtkMenuShell*", "GtkDirectionType"}, name ={"menushell", "direction"}} }, 
    deactivate           = {ret_type = "void"    , params = {type = {"GtkMenuShell*"}, name ={"menu_shell"}} }, 
    insert               = {ret_type = "void"    , params = {type = {"GtkMenuShell*", "GtkWidget*", "gint"}, name ={"menu_shell", "child", "position"}} }, 
    ['move-current']     = {ret_type = "void"    , params = {type = {"GtkMenuShell*", "GtkMenuDirectionType"}, name ={"menushell", "direction"}} }, 
    ['move-selected']    = {ret_type = "gboolean", params = {type = {"GtkMenuShell*", "gint"}, name ={"menushell", "distance"}} }, 
    ['selection-done']   = {ret_type = "void"    , params = {type = {"GtkMenuShell*"}, name ={"menushell"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["take-focus"] = {__type__="gboolean" ,__default__ = "TRUE" , __gencode__ = {"gtk_menu_shell_set_take_focus((GtkMenuShell*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk324.GtkContainer,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkNotebook
Gtk324.GtkNotebook = {
  class = "GtkNotebook", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_notebook_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    change_current_page = {"gboolean"    , {"GtkNotebook*", "gint"}, {"notebook", "offset"} }, 
    create_window       = {"GtkNotebook*", {"GtkNotebook*", "GtkWidget*", "gint", "gint"}, {"notebook", "page", "x", "y"} }, 
    focus_tab           = {"gboolean"    , {"GtkNotebook*", "GtkNotebookTab"}, {"notebook", "type"} }, 
    insert_page         = {"gint"        , {"GtkNotebook*", "GtkWidget*", "GtkWidget*", "GtkWidget*", "gint"}, {"notebook", "child", "tab_label", "menu_label", "position"} }, 
    move_focus_out      = {"void"        , {"GtkNotebook*", "GtkDirectionType"}, {"notebook", "direction"} }, 
    page_added          = {"void"        , {"GtkNotebook*", "GtkWidget*", "guint"}, {"notebook", "child", "page_num"} }, 
    page_removed        = {"void"        , {"GtkNotebook*", "GtkWidget*", "guint"}, {"notebook", "child", "page_num"} }, 
    page_reordered      = {"void"        , {"GtkNotebook*", "GtkWidget*", "guint"}, {"notebook", "child", "page_num"} }, 
    reorder_tab         = {"gboolean"    , {"GtkNotebook*", "GtkDirectionType", "gboolean"}, {"notebook", "direction", "move_to_last"} }, 
    select_page         = {"gboolean"    , {"GtkNotebook*", "gboolean"}, {"notebook", "move_focus"} }, 
    switch_page         = {"void"        , {"GtkNotebook*", "GtkWidget*", "guint"}, {"notebook", "page", "page_num"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['change-current-page'] = {ret_type = "gboolean"  , params = {type = {"GtkNotebook*", "gint"}, name ={"notebook", "object"}} }, 
    ['create-window']       = {ret_type = "{Notebook}", params = {type = {"GtkNotebook*", "GtkWidget*", "gint", "gint"}, name ={"notebook", "page", "x", "y"}} }, 
    ['focus-tab']           = {ret_type = "gboolean"  , params = {type = {"GtkNotebook*", "GtkNotebookTab"}, name ={"notebook", "object"}} }, 
    ['move-focus-out']      = {ret_type = "void"      , params = {type = {"GtkNotebook*", "GtkDirectionType"}, name ={"notebook", "object"}} }, 
    ['page-added']          = {ret_type = "void"      , params = {type = {"GtkNotebook*", "GtkWidget*", "guint"}, name ={"notebook", "child", "page_num"}} }, 
    ['page-removed']        = {ret_type = "void"      , params = {type = {"GtkNotebook*", "GtkWidget*", "guint"}, name ={"notebook", "child", "page_num"}} }, 
    ['page-reordered']      = {ret_type = "void"      , params = {type = {"GtkNotebook*", "GtkWidget*", "guint"}, name ={"notebook", "child", "page_num"}} }, 
    ['reorder-tab']         = {ret_type = "gboolean"  , params = {type = {"GtkNotebook*", "GtkDirectionType", "gboolean"}, name ={"notebook", "object", "p0"}} }, 
    ['select-page']         = {ret_type = "gboolean"  , params = {type = {"GtkNotebook*", "gboolean"}, name ={"notebook", "object"}} }, 
    ['switch-page']         = {ret_type = "void"      , params = {type = {"GtkNotebook*", "GtkWidget*", "guint"}, name ={"notebook", "page", "page_num"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["enable-popup"] = {__type__="gboolean"        ,__default__ = "FALSE"       ,rwflags="rw" },
    ["group-name"]   = {__type__="gchar*"          ,__default__ = "NULL"        , __gencode__ = {"gtk_notebook_set_group_name((GtkNotebook*)({* id *}), (const gchar*)({* property.value *}))"} },
    page             = {__type__="gint"            ,__default__ = "-1"          ,rwflags="rw" },
    scrollable       = {__type__="gboolean"        ,__default__ = "FALSE"       , __gencode__ = {"gtk_notebook_set_scrollable((GtkNotebook*)({* id *}), (gboolean)({* property.value *}))"} },
    ["show-border"]  = {__type__="gboolean"        ,__default__ = "TRUE"        , __gencode__ = {"gtk_notebook_set_show_border((GtkNotebook*)({* id *}), (gboolean)({* property.value *}))"} },
    ["show-tabs"]    = {__type__="gboolean"        ,__default__ = "TRUE"        , __gencode__ = {"gtk_notebook_set_show_tabs((GtkNotebook*)({* id *}), (gboolean)({* property.value *}))"} },
    ["tab-pos"]      = {__type__="GtkPositionType" ,__default__ = "GTK_POS_TOP" , __gencode__ = {"gtk_notebook_set_tab_pos((GtkNotebook*)({* id *}), (GtkPositionType)({* property.value *}))"} },
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    detachable     = {__type__="gboolean" ,__default__ = "FALSE" },
    ["menu-label"] = {__type__="gchar*"   ,__default__ = "NULL" },
    position       = {__type__="gint"     ,__default__ = "0" },
    reorderable    = {__type__="gboolean" ,__default__ = "FALSE" },
    ["tab-expand"] = {__type__="gboolean" ,__default__ = "FALSE" },
    ["tab-fill"]   = {__type__="gboolean" ,__default__ = "TRUE" },
    ["tab-label"]  = {__type__="gchar*"   ,__default__ = "NULL" },
  },
  parent = Gtk324.GtkContainer,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkPaned
Gtk324.GtkPaned = {
  class = "GtkPaned", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_paned_new((GtkOrientation)({* this.orientation.value *}))", 
            params = { type = {"GtkOrientation"}, 
                       name = {"orientation"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    accept_position     = {"gboolean", {"GtkPaned*"}, {"paned"} }, 
    cancel_position     = {"gboolean", {"GtkPaned*"}, {"paned"} }, 
    cycle_child_focus   = {"gboolean", {"GtkPaned*", "gboolean"}, {"paned", "reverse"} }, 
    cycle_handle_focus  = {"gboolean", {"GtkPaned*", "gboolean"}, {"paned", "reverse"} }, 
    move_handle         = {"gboolean", {"GtkPaned*", "GtkScrollType"}, {"paned", "scroll"} }, 
    toggle_handle_focus = {"gboolean", {"GtkPaned*"}, {"paned"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['accept-position']     = {ret_type = "gboolean", params = {type = {"GtkPaned*"}, name ={"paned"}} }, 
    ['cancel-position']     = {ret_type = "gboolean", params = {type = {"GtkPaned*"}, name ={"paned"}} }, 
    ['cycle-child-focus']   = {ret_type = "gboolean", params = {type = {"GtkPaned*", "gboolean"}, name ={"paned", "reversed"}} }, 
    ['cycle-handle-focus']  = {ret_type = "gboolean", params = {type = {"GtkPaned*", "gboolean"}, name ={"paned", "reversed"}} }, 
    ['move-handle']         = {ret_type = "gboolean", params = {type = {"GtkPaned*", "GtkScrollType"}, name ={"paned", "scroll_type"}} }, 
    ['toggle-handle-focus'] = {ret_type = "gboolean", params = {type = {"GtkPaned*"}, name ={"paned"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["max-position"] = {__type__="gint"     ,__default__ = "2147483647"  },
    ["min-position"] = {__type__="gint"     ,__default__ = "0"           },
    position         = {__type__="gint"     ,__default__ = "0"          , __gencode__ = {"gtk_paned_set_position((GtkPaned*)({* id *}), (gint)({* property.value *}))"} },
    ["position-set"] = {__type__="gboolean" ,__default__ = "FALSE"      ,rwflags="rw" },
    ["wide-handle"]  = {__type__="gboolean" ,__default__ = "FALSE"      , __gencode__ = {"gtk_paned_set_wide_handle((GtkPaned*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    resize = {__type__="gboolean" ,__default__ = "TRUE" },
    shrink = {__type__="gboolean" ,__default__ = "TRUE" },
  },
  parent = Gtk324.GtkContainer,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkProgressBarAccessible
Gtk324.GtkProgressBarAccessible = {
  class = "GtkProgressBarAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkWidgetAccessible,
};

---------------------  GtkRadioAction
Gtk324.GtkRadioAction = {
  class = "GtkRadioAction", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_radio_action_new((const gchar*)({* this.name.value *}), (const gchar*)({* this.label.value *}), (const gchar*)({* this.tooltip.value *}), (const gchar*)({* this['stock-id'].value *}), (gint)({* this.value.value *}))", 
            params = { type = {"const gchar*", "const gchar*", "const gchar*", "const gchar*", "gint"}, 
                       name = {"name", "label", "tooltip", "stock-id", "value"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    changed = {"void", {"GtkRadioAction*", "GtkRadioAction*"}, {"action", "current"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed = {ret_type = "void", params = {type = {"GtkRadioAction*", "GtkRadioAction*"}, name ={"action", "current"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["current-value"] = {__type__="gint"            ,__default__ = "0" , __gencode__ = {"gtk_radio_action_set_current_value((GtkRadioAction*)({* id *}), (gint)({* property.value *}))"} },
    group             = {__type__="GtkRadioAction*"                    , __gencode__ = {"gtk_radio_action_set_group((GtkRadioAction*)({* id *}), (GSList*)({* property.value *}))"} },
    value             = {__type__="gint"            ,__default__ = "0" ,rwflags="rw" },
  },
  parent = Gtk324.GtkToggleAction,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkRangeAccessible
Gtk324.GtkRangeAccessible = {
  class = "GtkRangeAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkWidgetAccessible,
};

---------------------  GtkRendererCellAccessible
Gtk324.GtkRendererCellAccessible = {
  class = "GtkRendererCellAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_renderer_cell_accessible_new((GtkCellRenderer*)({* this.renderer.value *}))", 
            params = { type = {"GtkCellRenderer*"}, 
                       name = {"renderer"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    renderer = {__type__="{CellRenderer}"  },
  },
  parent = Gtk324.GtkCellAccessible,
};

---------------------  GtkScale
Gtk324.GtkScale = {
  class = "GtkScale", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_scale_new((GtkOrientation)({* this.orientation.value *}), (GtkAdjustment*)({* this.adjustment.value *}))", 
            params = { type = {"GtkOrientation", "GtkAdjustment*"}, 
                       name = {"orientation", "adjustment"} } },
    new_with_range = { gencode = "gtk_scale_new_with_range((GtkOrientation)({* this.orientation.value *}), (gdouble)({* this.min.value *}), (gdouble)({* this.max.value *}), (gdouble)({* this.step.value *}))", 
            params = { type = {"GtkOrientation"}, 
                       name = {"orientation"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    draw_value         = {"void"  , {"GtkScale*"}, {"scale"} }, 
    format_value       = {"gchar*", {"GtkScale*", "gdouble"}, {"scale", "value"} }, 
    get_layout_offsets = {"void"  , {"GtkScale*", "gint*", "gint*"}, {"scale", "x", "y"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['format-value'] = {ret_type = "gchar*", params = {type = {"GtkScale*", "gdouble"}, name ={"scale", "value"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    digits         = {__type__="gint"            ,__default__ = "1"           , __gencode__ = {"gtk_scale_set_digits((GtkScale*)({* id *}), (gint)({* property.value *}))"} },
    ["draw-value"] = {__type__="gboolean"        ,__default__ = "TRUE"        , __gencode__ = {"gtk_scale_set_draw_value((GtkScale*)({* id *}), (gboolean)({* property.value *}))"} },
    ["has-origin"] = {__type__="gboolean"        ,__default__ = "TRUE"        , __gencode__ = {"gtk_scale_set_has_origin((GtkScale*)({* id *}), (gboolean)({* property.value *}))"} },
    ["value-pos"]  = {__type__="GtkPositionType" ,__default__ = "GTK_POS_TOP" , __gencode__ = {"gtk_scale_set_value_pos((GtkScale*)({* id *}), (GtkPositionType)({* property.value *}))"} },
  },
  parent = Gtk324.GtkRange,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkScrollbar
Gtk324.GtkScrollbar = {
  class = "GtkScrollbar", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_scrollbar_new((GtkOrientation)({* this.orientation.value *}), (GtkAdjustment*)({* this.adjustment.value *}))", 
            params = { type = {"GtkOrientation", "GtkAdjustment*"}, 
                       name = {"orientation", "adjustment"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkRange,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkSearchEntry
Gtk324.GtkSearchEntry = {
  class = "GtkSearchEntry", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_search_entry_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    next_match     = {"void", {"GtkSearchEntry*"}, {"entry"} }, 
    previous_match = {"void", {"GtkSearchEntry*"}, {"entry"} }, 
    search_changed = {"void", {"GtkSearchEntry*"}, {"entry"} }, 
    stop_search    = {"void", {"GtkSearchEntry*"}, {"entry"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['next-match']     = {ret_type = "void", params = {type = {"GtkSearchEntry*"}, name ={"searchentry"}} }, 
    ['previous-match'] = {ret_type = "void", params = {type = {"GtkSearchEntry*"}, name ={"searchentry"}} }, 
    ['search-changed'] = {ret_type = "void", params = {type = {"GtkSearchEntry*"}, name ={"searchentry"}} }, 
    ['stop-search']    = {ret_type = "void", params = {type = {"GtkSearchEntry*"}, name ={"searchentry"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkEntry,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkCellEditable, Gtk324.GtkEditable}, 
};

---------------------  GtkSocket
Gtk324.GtkSocket = {
  class = "GtkSocket", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_socket_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    plug_added   = {"void"    , {"GtkSocket*"}, {"socket_"} }, 
    plug_removed = {"gboolean", {"GtkSocket*"}, {"socket_"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['plug-added']   = {ret_type = "void"    , params = {type = {"GtkSocket*"}, name ={"socket"}} }, 
    ['plug-removed'] = {ret_type = "gboolean", params = {type = {"GtkSocket*"}, name ={"socket"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkContainer,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkSpinButton
Gtk324.GtkSpinButton = {
  class = "GtkSpinButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_spin_button_new((GtkAdjustment*)({* this.adjustment.value *}), (gdouble)({* this['climb-rate'].value *}), (guint)({* this.digits.value *}))", 
            params = { type = {"GtkAdjustment*", "gdouble", "guint"}, 
                       name = {"adjustment", "climb-rate", "digits"} } },
    new_with_range = { gencode = "gtk_spin_button_new_with_range((gdouble)({* this.min.value *}), (gdouble)({* this.max.value *}), (gdouble)({* this.step.value *}))", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    change_value  = {"void", {"GtkSpinButton*", "GtkScrollType"}, {"spin_button", "scroll"} }, 
    input         = {"gint", {"GtkSpinButton*", "gdouble*"}, {"spin_button", "new_value"} }, 
    output        = {"gint", {"GtkSpinButton*"}, {"spin_button"} }, 
    value_changed = {"void", {"GtkSpinButton*"}, {"spin_button"} }, 
    wrapped       = {"void", {"GtkSpinButton*"}, {"spin_button"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['change-value']  = {ret_type = "void", params = {type = {"GtkSpinButton*", "GtkScrollType"}, name ={"spinbutton", "scroll"}} }, 
    input             = {ret_type = "gint", params = {type = {"GtkSpinButton*", "gdouble*"}, name ={"spin_button", "new_value"}} }, 
    output            = {ret_type = "gint", params = {type = {"GtkSpinButton*"}, name ={"spin_button"}} }, 
    ['value-changed'] = {ret_type = "void", params = {type = {"GtkSpinButton*"}, name ={"spinbutton"}} }, 
    wrapped           = {ret_type = "void", params = {type = {"GtkSpinButton*"}, name ={"spin_button"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    adjustment        = {__type__="GtkAdjustment*"                                               , __gencode__ = {"gtk_spin_button_set_adjustment((GtkSpinButton*)({* id *}), (GtkAdjustment*)({* property.value *}))"} },
    ["climb-rate"]    = {__type__="gdouble"                   ,__default__ = "0"                 ,rwflags="rw" },
    digits            = {__type__="guint"                     ,__default__ = "0"                 , __gencode__ = {"gtk_spin_button_set_digits((GtkSpinButton*)({* id *}), (guint)({* property.value *}))"} },
    numeric           = {__type__="gboolean"                  ,__default__ = "FALSE"             , __gencode__ = {"gtk_spin_button_set_numeric((GtkSpinButton*)({* id *}), (gboolean)({* property.value *}))"} },
    ["snap-to-ticks"] = {__type__="gboolean"                  ,__default__ = "FALSE"             , __gencode__ = {"gtk_spin_button_set_snap_to_ticks((GtkSpinButton*)({* id *}), (gboolean)({* property.value *}))"} },
    ["update-policy"] = {__type__="GtkSpinButtonUpdatePolicy" ,__default__ = "GTK_UPDATE_ALWAYS" , __gencode__ = {"gtk_spin_button_set_update_policy((GtkSpinButton*)({* id *}), (GtkSpinButtonUpdatePolicy)({* property.value *}))"} },
    value             = {__type__="gdouble"                   ,__default__ = "0"                 , __gencode__ = {"gtk_spin_button_set_value((GtkSpinButton*)({* id *}), (gdouble)({* property.value *}))"} },
    wrap              = {__type__="gboolean"                  ,__default__ = "FALSE"             , __gencode__ = {"gtk_spin_button_set_wrap((GtkSpinButton*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk324.GtkEntry,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkCellEditable, Gtk324.GtkEditable, Gtk324.GtkOrientable}, 
};

---------------------  GtkSpinnerAccessible
Gtk324.GtkSpinnerAccessible = {
  class = "GtkSpinnerAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkWidgetAccessible,
};

---------------------  GtkStack
Gtk324.GtkStack = {
  class = "GtkStack", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_stack_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    hhomogeneous            = {__type__="gboolean"               ,__default__ = "TRUE"                           , __gencode__ = {"gtk_stack_set_hhomogeneous((GtkStack*)({* id *}), (gboolean)({* property.value *}))"} },
    homogeneous             = {__type__="gboolean"               ,__default__ = "TRUE"                           , __gencode__ = {"gtk_stack_set_homogeneous((GtkStack*)({* id *}), (gboolean)({* property.value *}))"} },
    ["interpolate-size"]    = {__type__="gboolean"               ,__default__ = "FALSE"                          , __gencode__ = {"gtk_stack_set_interpolate_size((GtkStack*)({* id *}), (gboolean)({* property.value *}))"} },
    ["transition-duration"] = {__type__="guint"                  ,__default__ = "200"                            , __gencode__ = {"gtk_stack_set_transition_duration((GtkStack*)({* id *}), (guint)({* property.value *}))"} },
    ["transition-running"]  = {__type__="gboolean"               ,__default__ = "FALSE"                           },
    ["transition-type"]     = {__type__="GtkStackTransitionType" ,__default__ = "GTK_STACK_TRANSITION_TYPE_NONE" , __gencode__ = {"gtk_stack_set_transition_type((GtkStack*)({* id *}), (GtkStackTransitionType)({* property.value *}))"} },
    vhomogeneous            = {__type__="gboolean"               ,__default__ = "TRUE"                           , __gencode__ = {"gtk_stack_set_vhomogeneous((GtkStack*)({* id *}), (gboolean)({* property.value *}))"} },
    ["visible-child"]       = {__type__="GtkWidget*"                                                             , __gencode__ = {"gtk_stack_set_visible_child((GtkStack*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["visible-child-name"]  = {__type__="gchar*"                 ,__default__ = "NULL"                           , __gencode__ = {"gtk_stack_set_visible_child_name((GtkStack*)({* id *}), (const gchar*)({* property.value *}))"} },
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    ["icon-name"]       = {__type__="gchar*"   ,__default__ = "NULL" },
    name                = {__type__="gchar*"   ,__default__ = "NULL" },
    ["needs-attention"] = {__type__="gboolean" ,__default__ = "FALSE" },
    position            = {__type__="gint"     ,__default__ = "0" },
    title               = {__type__="gchar*"   ,__default__ = "NULL" },
  },
  parent = Gtk324.GtkContainer,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkSwitchAccessible
Gtk324.GtkSwitchAccessible = {
  class = "GtkSwitchAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkWidgetAccessible,
};

---------------------  GtkTable
Gtk324.GtkTable = {
  class = "GtkTable", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_table_new((guint)({* this.rows.value *}), (guint)({* this.columns.value *}), (gboolean)({* this.homogeneous.value *}))", 
            params = { type = {"gboolean"}, 
                       name = {"homogeneous"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["column-spacing"] = {__type__="guint"    ,__default__ = "0"     ,rwflags="rw" },
    homogeneous        = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_table_set_homogeneous((GtkTable*)({* id *}), (gboolean)({* property.value *}))"} },
    ["n-columns"]      = {__type__="guint"    ,__default__ = "1"     ,rwflags="rw" },
    ["n-rows"]         = {__type__="guint"    ,__default__ = "1"     ,rwflags="rw" },
    ["row-spacing"]    = {__type__="guint"    ,__default__ = "0"     , __gencode__ = {"gtk_table_set_row_spacing((GtkTable*)({* id *}), (guint)({* property.value *}), (guint)({* property.value *}))"} },
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    ["bottom-attach"] = {__type__="guint"            ,__default__ = "1" },
    ["left-attach"]   = {__type__="guint"            ,__default__ = "0" },
    ["right-attach"]  = {__type__="guint"            ,__default__ = "1" },
    ["top-attach"]    = {__type__="guint"            ,__default__ = "0" },
    ["x-options"]     = {__type__="GtkAttachOptions" ,__default__ = "GTK_EXPAND | GTK_FILL" },
    ["x-padding"]     = {__type__="guint"            ,__default__ = "0" },
    ["y-options"]     = {__type__="GtkAttachOptions" ,__default__ = "GTK_EXPAND | GTK_FILL" },
    ["y-padding"]     = {__type__="guint"            ,__default__ = "0" },
  },
  parent = Gtk324.GtkContainer,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkTextView
Gtk324.GtkTextView = {
  class = "GtkTextView", 
  constructor = { 
    -- 名称[- ==> _], 
    new             = { gencode = "gtk_text_view_new()", 
            params = { type = {}, name = {} } },
    new_with_buffer = { gencode = "gtk_text_view_new_with_buffer((GtkTextBuffer*)({* this.buffer.value *}))", 
            params = { type = {"GtkTextBuffer*"}, 
                       name = {"buffer"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    backspace          = {"void"          , {"GtkTextView*"}, {"text_view"} }, 
    copy_clipboard     = {"void"          , {"GtkTextView*"}, {"text_view"} }, 
    create_buffer      = {"GtkTextBuffer*", {"GtkTextView*"}, {"text_view"} }, 
    cut_clipboard      = {"void"          , {"GtkTextView*"}, {"text_view"} }, 
    delete_from_cursor = {"void"          , {"GtkTextView*", "GtkDeleteType", "gint"}, {"text_view", "type", "count"} }, 
    draw_layer         = {"void"          , {"GtkTextView*", "GtkTextViewLayer", "cairo_t*"}, {"text_view", "layer", "cr"} }, 
    extend_selection   = {"gboolean"      , {"GtkTextView*", "GtkTextExtendSelection", "const GtkTextIter*", "GtkTextIter*", "GtkTextIter*"}, {"text_view", "granularity", "location", "start", "end"} }, 
    insert_at_cursor   = {"void"          , {"GtkTextView*", "const gchar*"}, {"text_view", "str"} }, 
    insert_emoji       = {"void"          , {"GtkTextView*"}, {"text_view"} }, 
    move_cursor        = {"void"          , {"GtkTextView*", "GtkMovementStep", "gint", "gboolean"}, {"text_view", "step", "count", "extend_selection"} }, 
    paste_clipboard    = {"void"          , {"GtkTextView*"}, {"text_view"} }, 
    populate_popup     = {"void"          , {"GtkTextView*", "GtkWidget*"}, {"text_view", "popup"} }, 
    set_anchor         = {"void"          , {"GtkTextView*"}, {"text_view"} }, 
    toggle_overwrite   = {"void"          , {"GtkTextView*"}, {"text_view"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    backspace                 = {ret_type = "void"    , params = {type = {"GtkTextView*"}, name ={"text_view"}} }, 
    ['copy-clipboard']        = {ret_type = "void"    , params = {type = {"GtkTextView*"}, name ={"textview"}} }, 
    ['cut-clipboard']         = {ret_type = "void"    , params = {type = {"GtkTextView*"}, name ={"textview"}} }, 
    ['delete-from-cursor']    = {ret_type = "void"    , params = {type = {"GtkTextView*", "GtkDeleteType", "gint"}, name ={"textview", "type", "count"}} }, 
    ['extend-selection']      = {ret_type = "gboolean", params = {type = {"GtkTextView*", "GtkTextExtendSelection", "GtkTextIter*", "GtkTextIter*", "GtkTextIter*"}, name ={"textview", "granularity", "location", "start", "end"}} }, 
    ['insert-at-cursor']      = {ret_type = "void"    , params = {type = {"GtkTextView*", "gchar*"}, name ={"textview", "string"}} }, 
    ['insert-emoji']          = {ret_type = "void"    , params = {type = {"GtkTextView*"}, name ={"textview"}} }, 
    ['move-cursor']           = {ret_type = "void"    , params = {type = {"GtkTextView*", "GtkMovementStep", "gint", "gboolean"}, name ={"textview", "step", "count", "extend_selection"}} }, 
    ['move-viewport']         = {ret_type = "void"    , params = {type = {"GtkTextView*", "GtkScrollStep", "gint"}, name ={"textview", "step", "count"}} }, 
    ['paste-clipboard']       = {ret_type = "void"    , params = {type = {"GtkTextView*"}, name ={"textview"}} }, 
    ['populate-popup']        = {ret_type = "void"    , params = {type = {"GtkTextView*", "GtkWidget*"}, name ={"textview", "popup"}} }, 
    ['preedit-changed']       = {ret_type = "void"    , params = {type = {"GtkTextView*", "gchar*"}, name ={"textview", "preedit"}} }, 
    ['select-all']            = {ret_type = "void"    , params = {type = {"GtkTextView*", "gboolean"}, name ={"textview", "select"}} }, 
    ['set-anchor']            = {ret_type = "void"    , params = {type = {"GtkTextView*"}, name ={"textview"}} }, 
    ['toggle-cursor-visible'] = {ret_type = "void"    , params = {type = {"GtkTextView*"}, name ={"textview"}} }, 
    ['toggle-overwrite']      = {ret_type = "void"    , params = {type = {"GtkTextView*"}, name ={"textview"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["accepts-tab"]        = {__type__="gboolean"         ,__default__ = "TRUE"                        , __gencode__ = {"gtk_text_view_set_accepts_tab((GtkTextView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["bottom-margin"]      = {__type__="gint"             ,__default__ = "0"                           , __gencode__ = {"gtk_text_view_set_bottom_margin((GtkTextView*)({* id *}), (gint)({* property.value *}))"} },
    buffer                 = {__type__="GtkTextBuffer*"                                                , __gencode__ = {"gtk_text_view_set_buffer((GtkTextView*)({* id *}), (GtkTextBuffer*)({* property.value *}))"} },
    ["cursor-visible"]     = {__type__="gboolean"         ,__default__ = "TRUE"                        , __gencode__ = {"gtk_text_view_set_cursor_visible((GtkTextView*)({* id *}), (gboolean)({* property.value *}))"} },
    editable               = {__type__="gboolean"         ,__default__ = "TRUE"                        , __gencode__ = {"gtk_text_view_set_editable((GtkTextView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["im-module"]          = {__type__="gchar*"           ,__default__ = "NULL"                        ,rwflags="rw" },
    indent                 = {__type__="gint"             ,__default__ = "0"                           , __gencode__ = {"gtk_text_view_set_indent((GtkTextView*)({* id *}), (gint)({* property.value *}))"} },
    ["input-hints"]        = {__type__="GtkInputHints"                                                 , __gencode__ = {"gtk_text_view_set_input_hints((GtkTextView*)({* id *}), (GtkInputHints)({* property.value *}))"} },
    ["input-purpose"]      = {__type__="GtkInputPurpose"  ,__default__ = "GTK_INPUT_PURPOSE_FREE_FORM" , __gencode__ = {"gtk_text_view_set_input_purpose((GtkTextView*)({* id *}), (GtkInputPurpose)({* property.value *}))"} },
    justification          = {__type__="GtkJustification" ,__default__ = "GTK_JUSTIFY_LEFT"            , __gencode__ = {"gtk_text_view_set_justification((GtkTextView*)({* id *}), (GtkJustification)({* property.value *}))"} },
    ["left-margin"]        = {__type__="gint"             ,__default__ = "0"                           , __gencode__ = {"gtk_text_view_set_left_margin((GtkTextView*)({* id *}), (gint)({* property.value *}))"} },
    monospace              = {__type__="gboolean"         ,__default__ = "FALSE"                       , __gencode__ = {"gtk_text_view_set_monospace((GtkTextView*)({* id *}), (gboolean)({* property.value *}))"} },
    overwrite              = {__type__="gboolean"         ,__default__ = "FALSE"                       , __gencode__ = {"gtk_text_view_set_overwrite((GtkTextView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["pixels-above-lines"] = {__type__="gint"             ,__default__ = "0"                           , __gencode__ = {"gtk_text_view_set_pixels_above_lines((GtkTextView*)({* id *}), (gint)({* property.value *}))"} },
    ["pixels-below-lines"] = {__type__="gint"             ,__default__ = "0"                           , __gencode__ = {"gtk_text_view_set_pixels_below_lines((GtkTextView*)({* id *}), (gint)({* property.value *}))"} },
    ["pixels-inside-wrap"] = {__type__="gint"             ,__default__ = "0"                           , __gencode__ = {"gtk_text_view_set_pixels_inside_wrap((GtkTextView*)({* id *}), (gint)({* property.value *}))"} },
    ["populate-all"]       = {__type__="gboolean"         ,__default__ = "FALSE"                       ,rwflags="rw" },
    ["right-margin"]       = {__type__="gint"             ,__default__ = "0"                           , __gencode__ = {"gtk_text_view_set_right_margin((GtkTextView*)({* id *}), (gint)({* property.value *}))"} },
    tabs                   = {__type__="PangoTabArray*"                                                , __gencode__ = {"gtk_text_view_set_tabs((GtkTextView*)({* id *}), (PangoTabArray*)({* property.value *}))"} },
    ["top-margin"]         = {__type__="gint"             ,__default__ = "0"                           , __gencode__ = {"gtk_text_view_set_top_margin((GtkTextView*)({* id *}), (gint)({* property.value *}))"} },
    ["wrap-mode"]          = {__type__="GtkWrapMode"      ,__default__ = "GTK_WRAP_NONE"               , __gencode__ = {"gtk_text_view_set_wrap_mode((GtkTextView*)({* id *}), (GtkWrapMode)({* property.value *}))"} },
  },
  parent = Gtk324.GtkContainer,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkScrollable}, 
};

---------------------  GtkToolItemGroup
Gtk324.GtkToolItemGroup = {
  class = "GtkToolItemGroup", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_tool_item_group_new((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    collapsed         = {__type__="gboolean"           ,__default__ = "FALSE"                , __gencode__ = {"gtk_tool_item_group_set_collapsed((GtkToolItemGroup*)({* id *}), (gboolean)({* property.value *}))"} },
    ellipsize         = {__type__="PangoEllipsizeMode" ,__default__ = "PANGO_ELLIPSIZE_NONE" , __gencode__ = {"gtk_tool_item_group_set_ellipsize((GtkToolItemGroup*)({* id *}), (PangoEllipsizeMode)({* property.value *}))"} },
    ["header-relief"] = {__type__="GtkReliefStyle"     ,__default__ = "GTK_RELIEF_NORMAL"    , __gencode__ = {"gtk_tool_item_group_set_header_relief((GtkToolItemGroup*)({* id *}), (GtkReliefStyle)({* property.value *}))"} },
    label             = {__type__="gchar*"             ,__default__ = "\"\""                 , __gencode__ = {"gtk_tool_item_group_set_label((GtkToolItemGroup*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["label-widget"]  = {__type__="GtkWidget*"                                               , __gencode__ = {"gtk_tool_item_group_set_label_widget((GtkToolItemGroup*)({* id *}), (GtkWidget*)({* property.value *}))"} },
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    expand      = {__type__="gboolean" ,__default__ = "FALSE" },
    fill        = {__type__="gboolean" ,__default__ = "TRUE" },
    homogeneous = {__type__="gboolean" ,__default__ = "TRUE" },
    ["new-row"] = {__type__="gboolean" ,__default__ = "FALSE" },
    position    = {__type__="gint"     ,__default__ = "0" },
  },
  parent = Gtk324.GtkContainer,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkToolShell}, 
};

---------------------  GtkToolPalette
Gtk324.GtkToolPalette = {
  class = "GtkToolPalette", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_tool_palette_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["icon-size"]     = {__type__="GtkIconSize"     ,__default__ = "GTK_ICON_SIZE_SMALL_TOOLBAR" , __gencode__ = {"gtk_tool_palette_set_icon_size((GtkToolPalette*)({* id *}), (GtkIconSize)({* property.value *}))"} },
    ["icon-size-set"] = {__type__="gboolean"        ,__default__ = "FALSE"                       ,rwflags="rw" },
    ["toolbar-style"] = {__type__="GtkToolbarStyle" ,__default__ = "GTK_TOOLBAR_ICONS"           ,rwflags="rw" },
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    exclusive = {__type__="gboolean" ,__default__ = "FALSE" },
    expand    = {__type__="gboolean" ,__default__ = "FALSE" },
  },
  parent = Gtk324.GtkContainer,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable, Gtk324.GtkScrollable}, 
};

---------------------  GtkToolbar
Gtk324.GtkToolbar = {
  class = "GtkToolbar", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_toolbar_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    orientation_changed = {"void"    , {"GtkToolbar*", "GtkOrientation"}, {"toolbar", "orientation"} }, 
    popup_context_menu  = {"gboolean", {"GtkToolbar*", "gint", "gint", "gint"}, {"toolbar", "x", "y", "button_number"} }, 
    style_changed       = {"void"    , {"GtkToolbar*", "GtkToolbarStyle"}, {"toolbar", "style"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['focus-home-or-end']   = {ret_type = "gboolean", params = {type = {"GtkToolbar*", "gboolean"}, name ={"toolbar", "focus_home"}} }, 
    ['orientation-changed'] = {ret_type = "void"    , params = {type = {"GtkToolbar*", "GtkOrientation"}, name ={"toolbar", "orientation"}} }, 
    ['popup-context-menu']  = {ret_type = "gboolean", params = {type = {"GtkToolbar*", "gint", "gint", "gint"}, name ={"toolbar", "x", "y", "button"}} }, 
    ['style-changed']       = {ret_type = "void"    , params = {type = {"GtkToolbar*", "GtkToolbarStyle"}, name ={"toolbar", "style"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["icon-size"]     = {__type__="GtkIconSize"     ,__default__ = "GTK_ICON_SIZE_LARGE_TOOLBAR" , __gencode__ = {"gtk_toolbar_set_icon_size((GtkToolbar*)({* id *}), (GtkIconSize)({* property.value *}))"} },
    ["icon-size-set"] = {__type__="gboolean"        ,__default__ = "FALSE"                       ,rwflags="rw" },
    ["show-arrow"]    = {__type__="gboolean"        ,__default__ = "TRUE"                        , __gencode__ = {"gtk_toolbar_set_show_arrow((GtkToolbar*)({* id *}), (gboolean)({* property.value *}))"} },
    ["toolbar-style"] = {__type__="GtkToolbarStyle" ,__default__ = "GTK_TOOLBAR_BOTH_HORIZ"      ,rwflags="rw" },
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    expand      = {__type__="gboolean" ,__default__ = "FALSE" },
    homogeneous = {__type__="gboolean" ,__default__ = "FALSE" },
  },
  parent = Gtk324.GtkContainer,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable, Gtk324.GtkToolShell}, 
};

---------------------  GtkTreeView
Gtk324.GtkTreeView = {
  class = "GtkTreeView", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_tree_view_new()", 
            params = { type = {}, name = {} } },
    new_with_model = { gencode = "gtk_tree_view_new_with_model((GtkTreeModel*)({* this.model.value *}))", 
            params = { type = {"GtkTreeModel*"}, 
                       name = {"model"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    columns_changed            = {"void"    , {"GtkTreeView*"}, {"tree_view"} }, 
    cursor_changed             = {"void"    , {"GtkTreeView*"}, {"tree_view"} }, 
    expand_collapse_cursor_row = {"gboolean", {"GtkTreeView*", "gboolean", "gboolean", "gboolean"}, {"tree_view", "logical", "expand", "open_all"} }, 
    move_cursor                = {"gboolean", {"GtkTreeView*", "GtkMovementStep", "gint"}, {"tree_view", "step", "count"} }, 
    row_activated              = {"void"    , {"GtkTreeView*", "GtkTreePath*", "GtkTreeViewColumn*"}, {"tree_view", "path", "column"} }, 
    row_collapsed              = {"void"    , {"GtkTreeView*", "GtkTreeIter*", "GtkTreePath*"}, {"tree_view", "iter", "path"} }, 
    row_expanded               = {"void"    , {"GtkTreeView*", "GtkTreeIter*", "GtkTreePath*"}, {"tree_view", "iter", "path"} }, 
    select_all                 = {"gboolean", {"GtkTreeView*"}, {"tree_view"} }, 
    select_cursor_parent       = {"gboolean", {"GtkTreeView*"}, {"tree_view"} }, 
    select_cursor_row          = {"gboolean", {"GtkTreeView*", "gboolean"}, {"tree_view", "start_editing"} }, 
    start_interactive_search   = {"gboolean", {"GtkTreeView*"}, {"tree_view"} }, 
    test_collapse_row          = {"gboolean", {"GtkTreeView*", "GtkTreeIter*", "GtkTreePath*"}, {"tree_view", "iter", "path"} }, 
    test_expand_row            = {"gboolean", {"GtkTreeView*", "GtkTreeIter*", "GtkTreePath*"}, {"tree_view", "iter", "path"} }, 
    toggle_cursor_row          = {"gboolean", {"GtkTreeView*"}, {"tree_view"} }, 
    unselect_all               = {"gboolean", {"GtkTreeView*"}, {"tree_view"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['columns-changed']            = {ret_type = "void"    , params = {type = {"GtkTreeView*"}, name ={"treeview"}} }, 
    ['cursor-changed']             = {ret_type = "void"    , params = {type = {"GtkTreeView*"}, name ={"treeview"}} }, 
    ['expand-collapse-cursor-row'] = {ret_type = "gboolean", params = {type = {"GtkTreeView*", "gboolean", "gboolean", "gboolean"}, name ={"treeview", "object", "p0", "p1"}} }, 
    ['move-cursor']                = {ret_type = "gboolean", params = {type = {"GtkTreeView*", "GtkMovementStep", "gint"}, name ={"treeview", "step", "direction"}} }, 
    ['row-activated']              = {ret_type = "void"    , params = {type = {"GtkTreeView*", "GtkTreePath*", "GtkTreeViewColumn*"}, name ={"treeview", "path", "column"}} }, 
    ['row-collapsed']              = {ret_type = "void"    , params = {type = {"GtkTreeView*", "GtkTreeIter*", "GtkTreePath*"}, name ={"treeview", "iter", "path"}} }, 
    ['row-expanded']               = {ret_type = "void"    , params = {type = {"GtkTreeView*", "GtkTreeIter*", "GtkTreePath*"}, name ={"treeview", "iter", "path"}} }, 
    ['select-all']                 = {ret_type = "gboolean", params = {type = {"GtkTreeView*"}, name ={"treeview"}} }, 
    ['select-cursor-parent']       = {ret_type = "gboolean", params = {type = {"GtkTreeView*"}, name ={"treeview"}} }, 
    ['select-cursor-row']          = {ret_type = "gboolean", params = {type = {"GtkTreeView*", "gboolean"}, name ={"treeview", "object"}} }, 
    ['start-interactive-search']   = {ret_type = "gboolean", params = {type = {"GtkTreeView*"}, name ={"treeview"}} }, 
    ['test-collapse-row']          = {ret_type = "gboolean", params = {type = {"GtkTreeView*", "GtkTreeIter*", "GtkTreePath*"}, name ={"treeview", "iter", "path"}} }, 
    ['test-expand-row']            = {ret_type = "gboolean", params = {type = {"GtkTreeView*", "GtkTreeIter*", "GtkTreePath*"}, name ={"treeview", "iter", "path"}} }, 
    ['toggle-cursor-row']          = {ret_type = "gboolean", params = {type = {"GtkTreeView*"}, name ={"treeview"}} }, 
    ['unselect-all']               = {ret_type = "gboolean", params = {type = {"GtkTreeView*"}, name ={"treeview"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["activate-on-single-click"] = {__type__="gboolean"             ,__default__ = "FALSE"                         , __gencode__ = {"gtk_tree_view_set_activate_on_single_click((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["enable-grid-lines"]        = {__type__="GtkTreeViewGridLines" ,__default__ = "GTK_TREE_VIEW_GRID_LINES_NONE" ,rwflags="rw" },
    ["enable-search"]            = {__type__="gboolean"             ,__default__ = "TRUE"                          , __gencode__ = {"gtk_tree_view_set_enable_search((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["enable-tree-lines"]        = {__type__="gboolean"             ,__default__ = "FALSE"                         , __gencode__ = {"gtk_tree_view_set_enable_tree_lines((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["expander-column"]          = {__type__="GtkTreeViewColumn*"                                                  , __gencode__ = {"gtk_tree_view_set_expander_column((GtkTreeView*)({* id *}), (GtkTreeViewColumn*)({* property.value *}))"} },
    ["fixed-height-mode"]        = {__type__="gboolean"             ,__default__ = "FALSE"                         , __gencode__ = {"gtk_tree_view_set_fixed_height_mode((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["headers-clickable"]        = {__type__="gboolean"             ,__default__ = "TRUE"                          , __gencode__ = {"gtk_tree_view_set_headers_clickable((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["headers-visible"]          = {__type__="gboolean"             ,__default__ = "TRUE"                          , __gencode__ = {"gtk_tree_view_set_headers_visible((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["hover-expand"]             = {__type__="gboolean"             ,__default__ = "FALSE"                         , __gencode__ = {"gtk_tree_view_set_hover_expand((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["hover-selection"]          = {__type__="gboolean"             ,__default__ = "FALSE"                         , __gencode__ = {"gtk_tree_view_set_hover_selection((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["level-indentation"]        = {__type__="gint"                 ,__default__ = "0"                             , __gencode__ = {"gtk_tree_view_set_level_indentation((GtkTreeView*)({* id *}), (gint)({* property.value *}))"} },
    model                        = {__type__="GtkTreeModel*"                                                       , __gencode__ = {"gtk_tree_view_set_model((GtkTreeView*)({* id *}), (GtkTreeModel*)({* property.value *}))"} },
    reorderable                  = {__type__="gboolean"             ,__default__ = "FALSE"                         , __gencode__ = {"gtk_tree_view_set_reorderable((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["rubber-banding"]           = {__type__="gboolean"             ,__default__ = "FALSE"                         , __gencode__ = {"gtk_tree_view_set_rubber_banding((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["rules-hint"]               = {__type__="gboolean"             ,__default__ = "FALSE"                         , __gencode__ = {"gtk_tree_view_set_rules_hint((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["search-column"]            = {__type__="gint"                 ,__default__ = "-1"                            , __gencode__ = {"gtk_tree_view_set_search_column((GtkTreeView*)({* id *}), (gint)({* property.value *}))"} },
    ["show-expanders"]           = {__type__="gboolean"             ,__default__ = "TRUE"                          , __gencode__ = {"gtk_tree_view_set_show_expanders((GtkTreeView*)({* id *}), (gboolean)({* property.value *}))"} },
    ["tooltip-column"]           = {__type__="gint"                 ,__default__ = "-1"                            , __gencode__ = {"gtk_tree_view_set_tooltip_column((GtkTreeView*)({* id *}), (gint)({* property.value *}))"} },
  },
  parent = Gtk324.GtkContainer,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkScrollable}, 
};

---------------------  GtkVSeparator
Gtk324.GtkVSeparator = {
  class = "GtkVSeparator", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_vseparator_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkSeparator,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkAccelLabel
Gtk324.GtkAccelLabel = {
  class = "GtkAccelLabel", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_accel_label_new((const gchar*)({* this.string.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["accel-closure"] = {__type__="GClosure*"  , __gencode__ = {"gtk_accel_label_set_accel_closure((GtkAccelLabel*)({* id *}), (GClosure*)({* property.value *}))"} },
    ["accel-widget"]  = {__type__="GtkWidget*" , __gencode__ = {"gtk_accel_label_set_accel_widget((GtkAccelLabel*)({* id *}), (GtkWidget*)({* property.value *}))"} },
  },
  parent = Gtk324.GtkLabel,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkActionBar
Gtk324.GtkActionBar = {
  class = "GtkActionBar", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_action_bar_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    ["pack-type"] = {__type__="GtkPackType" ,__default__ = "GTK_PACK_START" },
    position      = {__type__="gint"        ,__default__ = "0" },
  },
  parent = Gtk324.GtkBin,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkAlignment
Gtk324.GtkAlignment = {
  class = "GtkAlignment", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_alignment_new((gfloat)({* this.xalign.value *}), (gfloat)({* this.yalign.value *}), (gfloat)({* this.xscale.value *}), (gfloat)({* this.yscale.value *}))", 
            params = { type = {"gfloat", "gfloat", "gfloat", "gfloat"}, 
                       name = {"xalign", "yalign", "xscale", "yscale"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["bottom-padding"] = {__type__="guint"  ,__default__ = "0"   ,rwflags="rw" },
    ["left-padding"]   = {__type__="guint"  ,__default__ = "0"   ,rwflags="rw" },
    ["right-padding"]  = {__type__="guint"  ,__default__ = "0"   ,rwflags="rw" },
    ["top-padding"]    = {__type__="guint"  ,__default__ = "0"   ,rwflags="rw" },
    xalign             = {__type__="gfloat" ,__default__ = "0.5" ,rwflags="rw" },
    xscale             = {__type__="gfloat" ,__default__ = "1"   ,rwflags="rw" },
    yalign             = {__type__="gfloat" ,__default__ = "0.5" ,rwflags="rw" },
    yscale             = {__type__="gfloat" ,__default__ = "1"   ,rwflags="rw" },
  },
  parent = Gtk324.GtkBin,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkAppChooserWidget
Gtk324.GtkAppChooserWidget = {
  class = "GtkAppChooserWidget", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_app_chooser_widget_new((const gchar*)({* this['content-type']value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"content-type"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    application_activated = {"void", {"GtkAppChooserWidget*", "GAppInfo*"}, {"self", "app_info"} }, 
    application_selected  = {"void", {"GtkAppChooserWidget*", "GAppInfo*"}, {"self", "app_info"} }, 
    populate_popup        = {"void", {"GtkAppChooserWidget*", "GtkMenu*", "GAppInfo*"}, {"self", "menu", "app_info"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['application-activated'] = {ret_type = "void", params = {type = {"GtkAppChooserWidget*", "GAppInfo*"}, name ={"appchooserwidget", "application"}} }, 
    ['application-selected']  = {ret_type = "void", params = {type = {"GtkAppChooserWidget*", "GAppInfo*"}, name ={"appchooserwidget", "application"}} }, 
    ['populate-popup']        = {ret_type = "void", params = {type = {"GtkAppChooserWidget*", "GtkMenu*", "GAppInfo*"}, name ={"appchooserwidget", "menu", "application"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["default-text"]     = {__type__="gchar*"   ,__default__ = "NULL"  , __gencode__ = {"gtk_app_chooser_widget_set_default_text((GtkAppChooserWidget*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["show-all"]         = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_app_chooser_widget_set_show_all((GtkAppChooserWidget*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    ["show-default"]     = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_app_chooser_widget_set_show_default((GtkAppChooserWidget*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    ["show-fallback"]    = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_app_chooser_widget_set_show_fallback((GtkAppChooserWidget*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    ["show-other"]       = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_app_chooser_widget_set_show_other((GtkAppChooserWidget*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    ["show-recommended"] = {__type__="gboolean" ,__default__ = "TRUE"  , __gencode__ = {"gtk_app_chooser_widget_set_show_recommended((GtkAppChooserWidget*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
  },
  parent = Gtk324.GtkBox,
  implement = {Gtk324.GtkAppChooser, Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkBooleanCellAccessible
Gtk324.GtkBooleanCellAccessible = {
  class = "GtkBooleanCellAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkRendererCellAccessible,
};

---------------------  GtkButton
Gtk324.GtkButton = {
  class = "GtkButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new                = { gencode = "gtk_button_new()", 
            params = { type = {}, name = {} } },
    new_from_icon_name = { gencode = "gtk_button_new_from_icon_name((const gchar*)({* this.icon_name.value *}), (GtkIconSize)({* this.size.value *}))", 
            params = { type = {}, name = {} } },
    new_from_stock     = { gencode = "gtk_button_new_from_stock((const gchar*)({* this.stock_id.value *}))", 
            params = { type = {}, name = {} } },
    new_with_label     = { gencode = "gtk_button_new_with_label((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
    new_with_mnemonic  = { gencode = "gtk_button_new_with_mnemonic((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate = {"void", {"GtkButton*"}, {"button"} }, 
    clicked  = {"void", {"GtkButton*"}, {"button"} }, 
    enter    = {"void", {"GtkButton*"}, {"button"} }, 
    leave    = {"void", {"GtkButton*"}, {"button"} }, 
    pressed  = {"void", {"GtkButton*"}, {"button"} }, 
    released = {"void", {"GtkButton*"}, {"button"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate = {ret_type = "void", params = {type = {"GtkButton*"}, name ={"button"}} }, 
    clicked  = {ret_type = "void", params = {type = {"GtkButton*"}, name ={"button"}} }, 
    enter    = {ret_type = "void", params = {type = {"GtkButton*"}, name ={"button"}} }, 
    leave    = {ret_type = "void", params = {type = {"GtkButton*"}, name ={"button"}} }, 
    pressed  = {ret_type = "void", params = {type = {"GtkButton*"}, name ={"button"}} }, 
    released = {ret_type = "void", params = {type = {"GtkButton*"}, name ={"button"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["always-show-image"] = {__type__="gboolean"        ,__default__ = "FALSE"             , __gencode__ = {"gtk_button_set_always_show_image((GtkButton*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    image                 = {__type__="GtkWidget*"                                         , __gencode__ = {"gtk_button_set_image((GtkButton*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["image-position"]    = {__type__="GtkPositionType" ,__default__ = "GTK_POS_LEFT"      , __gencode__ = {"gtk_button_set_image_position((GtkButton*)({* id *}), (GtkPositionType)({* property.value *}))"} },
    label                 = {__type__="gchar*"          ,__default__ = "NULL"              , __gencode__ = {"gtk_button_set_label((GtkButton*)({* id *}), (const gchar*)({* property.value *}))"},__construct__= 1 },
    relief                = {__type__="GtkReliefStyle"  ,__default__ = "GTK_RELIEF_NORMAL" , __gencode__ = {"gtk_button_set_relief((GtkButton*)({* id *}), (GtkReliefStyle)({* property.value *}))"} },
    ["use-stock"]         = {__type__="gboolean"        ,__default__ = "FALSE"             , __gencode__ = {"gtk_button_set_use_stock((GtkButton*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    ["use-underline"]     = {__type__="gboolean"        ,__default__ = "FALSE"             , __gencode__ = {"gtk_button_set_use_underline((GtkButton*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    xalign                = {__type__="gfloat"          ,__default__ = "0.5"               ,rwflags="rw" },
    yalign                = {__type__="gfloat"          ,__default__ = "0.5"               ,rwflags="rw" },
  },
  parent = Gtk324.GtkBin,
  implement = {Gtk324.GtkActionable, Gtk324.GtkActivatable, Gtk324.GtkBuildable}, 
};

---------------------  GtkButtonAccessible
Gtk324.GtkButtonAccessible = {
  class = "GtkButtonAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkContainerAccessible,
};

---------------------  GtkButtonBox
Gtk324.GtkButtonBox = {
  class = "GtkButtonBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_button_box_new((GtkOrientation)({* this.orientation.value *}))", 
            params = { type = {"GtkOrientation"}, 
                       name = {"orientation"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["layout-style"] = {__type__="GtkButtonBoxStyle" ,__default__ = "GTK_BUTTONBOX_EDGE" ,rwflags="rw" },
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    ["non-homogeneous"] = {__type__="gboolean" ,__default__ = "FALSE" },
    secondary           = {__type__="gboolean" ,__default__ = "FALSE" },
  },
  parent = Gtk324.GtkBox,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkColorChooserWidget
Gtk324.GtkColorChooserWidget = {
  class = "GtkColorChooserWidget", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_color_chooser_widget_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["show-editor"] = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
  },
  parent = Gtk324.GtkBox,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkColorChooser, Gtk324.GtkOrientable}, 
};

---------------------  GtkColorSelection
Gtk324.GtkColorSelection = {
  class = "GtkColorSelection", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_color_selection_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    color_changed = {"void", {"GtkColorSelection*"}, {"color_selection"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['color-changed'] = {ret_type = "void", params = {type = {"GtkColorSelection*"}, name ={"colorselection"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["current-alpha"]       = {__type__="guint"     ,__default__ = "65535" , __gencode__ = {"gtk_color_selection_set_current_alpha((GtkColorSelection*)({* id *}), (guint16)({* property.value *}))"} },
    ["current-color"]       = {__type__="GdkColor*"                        , __gencode__ = {"gtk_color_selection_set_current_color((GtkColorSelection*)({* id *}), (const GdkColor*)({* property.value *}))"} },
    ["current-rgba"]        = {__type__="GdkRGBA*"                         , __gencode__ = {"gtk_color_selection_set_current_rgba((GtkColorSelection*)({* id *}), (const GdkRGBA*)({* property.value *}))"} },
    ["has-opacity-control"] = {__type__="gboolean"  ,__default__ = "FALSE" , __gencode__ = {"gtk_color_selection_set_has_opacity_control((GtkColorSelection*)({* id *}), (gboolean)({* property.value *}))"} },
    ["has-palette"]         = {__type__="gboolean"  ,__default__ = "FALSE" , __gencode__ = {"gtk_color_selection_set_has_palette((GtkColorSelection*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk324.GtkBox,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkComboBox
Gtk324.GtkComboBox = {
  class = "GtkComboBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new                      = { gencode = "gtk_combo_box_new()", 
            params = { type = {}, name = {} } },
    new_with_area            = { gencode = "gtk_combo_box_new_with_area((GtkCellArea*)({* this.area.value *}))", 
            params = { type = {}, name = {} } },
    new_with_area_and_entry  = { gencode = "gtk_combo_box_new_with_area_and_entry((GtkCellArea*)({* this.area.value *}))", 
            params = { type = {}, name = {} } },
    new_with_entry           = { gencode = "gtk_combo_box_new_with_entry()", 
            params = { type = {}, name = {} } },
    new_with_model           = { gencode = "gtk_combo_box_new_with_model((GtkTreeModel*)({* this.model.value *}))", 
            params = { type = {"GtkTreeModel*"}, 
                       name = {"model"} } },
    new_with_model_and_entry = { gencode = "gtk_combo_box_new_with_model_and_entry((GtkTreeModel*)({* this.model.value *}))", 
            params = { type = {"GtkTreeModel*"}, 
                       name = {"model"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    changed           = {"void"  , {"GtkComboBox*"}, {"combo_box"} }, 
    format_entry_text = {"gchar*", {"GtkComboBox*", "const gchar*"}, {"combo_box", "path"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    changed               = {ret_type = "void"    , params = {type = {"GtkComboBox*"}, name ={"combo_box"}} }, 
    ['format-entry-text'] = {ret_type = "gchar*"  , params = {type = {"GtkComboBox*", "gchar*"}, name ={"combobox", "path"}} }, 
    ['move-active']       = {ret_type = "void"    , params = {type = {"GtkComboBox*", "GtkScrollType"}, name ={"combobox", "scroll_type"}} }, 
    popdown               = {ret_type = "gboolean", params = {type = {"GtkComboBox*"}, name ={"combobox"}} }, 
    popup                 = {ret_type = "void"    , params = {type = {"GtkComboBox*"}, name ={"combobox"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    active                 = {__type__="gint"               ,__default__ = "-1"                   , __gencode__ = {"gtk_combo_box_set_active((GtkComboBox*)({* id *}), (gint)({* property.value *}))"} },
    ["active-id"]          = {__type__="gchar*"             ,__default__ = "NULL"                 , __gencode__ = {"gtk_combo_box_set_active_id((GtkComboBox*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["add-tearoffs"]       = {__type__="gboolean"           ,__default__ = "FALSE"                , __gencode__ = {"gtk_combo_box_set_add_tearoffs((GtkComboBox*)({* id *}), (gboolean)({* property.value *}))"} },
    ["button-sensitivity"] = {__type__="GtkSensitivityType" ,__default__ = "GTK_SENSITIVITY_AUTO" , __gencode__ = {"gtk_combo_box_set_button_sensitivity((GtkComboBox*)({* id *}), (GtkSensitivityType)({* property.value *}))"} },
    ["cell-area"]          = {__type__="GtkCellArea*"                                             ,rwflags="rw" },
    ["column-span-column"] = {__type__="gint"               ,__default__ = "-1"                   , __gencode__ = {"gtk_combo_box_set_column_span_column((GtkComboBox*)({* id *}), (gint)({* property.value *}))"} },
    ["entry-text-column"]  = {__type__="gint"               ,__default__ = "-1"                   , __gencode__ = {"gtk_combo_box_set_entry_text_column((GtkComboBox*)({* id *}), (gint)({* property.value *}))"} },
    ["has-entry"]          = {__type__="gboolean"           ,__default__ = "FALSE"                ,rwflags="rw" },
    ["has-frame"]          = {__type__="gboolean"           ,__default__ = "TRUE"                 ,rwflags="rw" },
    ["id-column"]          = {__type__="gint"               ,__default__ = "-1"                   , __gencode__ = {"gtk_combo_box_set_id_column((GtkComboBox*)({* id *}), (gint)({* property.value *}))"} },
    model                  = {__type__="GtkTreeModel*"                                            , __gencode__ = {"gtk_combo_box_set_model((GtkComboBox*)({* id *}), (GtkTreeModel*)({* property.value *}))"} },
    ["popup-fixed-width"]  = {__type__="gboolean"           ,__default__ = "TRUE"                 , __gencode__ = {"gtk_combo_box_set_popup_fixed_width((GtkComboBox*)({* id *}), (gboolean)({* property.value *}))"} },
    ["popup-shown"]        = {__type__="gboolean"           ,__default__ = "FALSE"                 },
    ["row-span-column"]    = {__type__="gint"               ,__default__ = "-1"                   , __gencode__ = {"gtk_combo_box_set_row_span_column((GtkComboBox*)({* id *}), (gint)({* property.value *}))"} },
    ["tearoff-title"]      = {__type__="gchar*"             ,__default__ = "NULL"                 ,rwflags="rw" },
    ["wrap-width"]         = {__type__="gint"               ,__default__ = "0"                    , __gencode__ = {"gtk_combo_box_set_wrap_width((GtkComboBox*)({* id *}), (gint)({* property.value *}))"} },
  },
  parent = Gtk324.GtkBin,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkCellEditable, Gtk324.GtkCellLayout}, 
};

---------------------  GtkComboBoxAccessible
Gtk324.GtkComboBoxAccessible = {
  class = "GtkComboBoxAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkContainerAccessible,
};

---------------------  GtkEventBox
Gtk324.GtkEventBox = {
  class = "GtkEventBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_event_box_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["above-child"]    = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_event_box_set_above_child((GtkEventBox*)({* id *}), (gboolean)({* property.value *}))"} },
    ["visible-window"] = {__type__="gboolean" ,__default__ = "TRUE"  , __gencode__ = {"gtk_event_box_set_visible_window((GtkEventBox*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk324.GtkBin,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkExpander
Gtk324.GtkExpander = {
  class = "GtkExpander", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_expander_new((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
    new_with_mnemonic = { gencode = "gtk_expander_new_with_mnemonic((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate = {"void", {"GtkExpander*"}, {"expander"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate = {ret_type = "void", params = {type = {"GtkExpander*"}, name ={"expander"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    expanded            = {__type__="gboolean"   ,__default__ = "FALSE" , __gencode__ = {"gtk_expander_set_expanded((GtkExpander*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    label               = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_expander_set_label((GtkExpander*)({* id *}), (const gchar*)({* property.value *}))"},__construct__= 1 },
    ["label-fill"]      = {__type__="gboolean"   ,__default__ = "FALSE" , __gencode__ = {"gtk_expander_set_label_fill((GtkExpander*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    ["label-widget"]    = {__type__="GtkWidget*"                        , __gencode__ = {"gtk_expander_set_label_widget((GtkExpander*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["resize-toplevel"] = {__type__="gboolean"   ,__default__ = "FALSE" , __gencode__ = {"gtk_expander_set_resize_toplevel((GtkExpander*)({* id *}), (gboolean)({* property.value *}))"} },
    spacing             = {__type__="gint"       ,__default__ = "0"     , __gencode__ = {"gtk_expander_set_spacing((GtkExpander*)({* id *}), (gint)({* property.value *}))"} },
    ["use-markup"]      = {__type__="gboolean"   ,__default__ = "FALSE" , __gencode__ = {"gtk_expander_set_use_markup((GtkExpander*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    ["use-underline"]   = {__type__="gboolean"   ,__default__ = "FALSE" , __gencode__ = {"gtk_expander_set_use_underline((GtkExpander*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
  },
  parent = Gtk324.GtkBin,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkExpanderAccessible
Gtk324.GtkExpanderAccessible = {
  class = "GtkExpanderAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkContainerAccessible,
};

---------------------  GtkFileChooserButton
Gtk324.GtkFileChooserButton = {
  class = "GtkFileChooserButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new             = { gencode = "gtk_file_chooser_button_new((const gchar*)({* this.title.value *}), (GtkFileChooserAction)({* this.action.value *}))", 
            params = { type = {"const gchar*", "GtkFileChooserAction"}, 
                       name = {"title", "action"} } },
    new_with_dialog = { gencode = "gtk_file_chooser_button_new_with_dialog((GtkWidget*)({* this.dialog.value *}))", 
            params = { type = {"GtkWidget*"}, 
                       name = {"dialog"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    file_set = {"void", {"GtkFileChooserButton*"}, {"fc"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['file-set'] = {ret_type = "void", params = {type = {"GtkFileChooserButton*"}, name ={"filechooserbutton"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    dialog          = {__type__="GtkFileChooser*"                                    ,rwflags="w" },
    title           = {__type__="gchar*"          ,__default__ = "\"Select a File\"" , __gencode__ = {"gtk_file_chooser_button_set_title((GtkFileChooserButton*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["width-chars"] = {__type__="gint"            ,__default__ = "-1"                , __gencode__ = {"gtk_file_chooser_button_set_width_chars((GtkFileChooserButton*)({* id *}), (gint)({* property.value *}))"} },
  },
  parent = Gtk324.GtkBox,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkFileChooser, Gtk324.GtkOrientable}, 
};

---------------------  GtkFileChooserWidget
Gtk324.GtkFileChooserWidget = {
  class = "GtkFileChooserWidget", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_file_chooser_widget_new((GtkFileChooserAction)({* this.action.value *}))", 
            params = { type = {"GtkFileChooserAction"}, 
                       name = {"action"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['desktop-folder']          = {ret_type = "void", params = {type = {"GtkFileChooserWidget*"}, name ={"filechooserwidget"}} }, 
    ['down-folder']             = {ret_type = "void", params = {type = {"GtkFileChooserWidget*"}, name ={"filechooserwidget"}} }, 
    ['home-folder']             = {ret_type = "void", params = {type = {"GtkFileChooserWidget*"}, name ={"filechooserwidget"}} }, 
    ['location-popup']          = {ret_type = "void", params = {type = {"GtkFileChooserWidget*", "gchar*"}, name ={"filechooserwidget", "path"}} }, 
    ['location-popup-on-paste'] = {ret_type = "void", params = {type = {"GtkFileChooserWidget*"}, name ={"filechooserwidget"}} }, 
    ['location-toggle-popup']   = {ret_type = "void", params = {type = {"GtkFileChooserWidget*"}, name ={"filechooserwidget"}} }, 
    ['places-shortcut']         = {ret_type = "void", params = {type = {"GtkFileChooserWidget*"}, name ={"filechooserwidget"}} }, 
    ['quick-bookmark']          = {ret_type = "void", params = {type = {"GtkFileChooserWidget*", "gint"}, name ={"filechooserwidget", "bookmark_index"}} }, 
    ['recent-shortcut']         = {ret_type = "void", params = {type = {"GtkFileChooserWidget*"}, name ={"filechooserwidget"}} }, 
    ['search-shortcut']         = {ret_type = "void", params = {type = {"GtkFileChooserWidget*"}, name ={"filechooserwidget"}} }, 
    ['show-hidden']             = {ret_type = "void", params = {type = {"GtkFileChooserWidget*"}, name ={"filechooserwidget"}} }, 
    ['up-folder']               = {ret_type = "void", params = {type = {"GtkFileChooserWidget*"}, name ={"filechooserwidget"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["search-mode"] = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
    subtitle        = {__type__="gchar*"   ,__default__ = "\"\""   },
  },
  parent = Gtk324.GtkBox,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkFileChooser, Gtk324.GtkOrientable}, 
};

---------------------  GtkFileChooserWidgetAccessible
Gtk324.GtkFileChooserWidgetAccessible = {
  class = "GtkFileChooserWidgetAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkContainerAccessible,
};

---------------------  GtkFlowBoxAccessible
Gtk324.GtkFlowBoxAccessible = {
  class = "GtkFlowBoxAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkContainerAccessible,
};

---------------------  GtkFlowBoxChild
Gtk324.GtkFlowBoxChild = {
  class = "GtkFlowBoxChild", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_flow_box_child_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate = {"void", {"GtkFlowBoxChild*"}, {"child"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate = {ret_type = "void", params = {type = {"GtkFlowBoxChild*"}, name ={"child"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkBin,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkFlowBoxChildAccessible
Gtk324.GtkFlowBoxChildAccessible = {
  class = "GtkFlowBoxChildAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkContainerAccessible,
};

---------------------  GtkFontChooserWidget
Gtk324.GtkFontChooserWidget = {
  class = "GtkFontChooserWidget", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_font_chooser_widget_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["tweak-action"] = {__type__="GAction*"  },
  },
  parent = Gtk324.GtkBox,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkFontChooser, Gtk324.GtkOrientable}, 
};

---------------------  GtkFontSelection
Gtk324.GtkFontSelection = {
  class = "GtkFontSelection", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_font_selection_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["font-name"]    = {__type__="gchar*" ,__default__ = "\"Sans 10\""                 , __gencode__ = {"gtk_font_selection_set_font_name((GtkFontSelection*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["preview-text"] = {__type__="gchar*" ,__default__ = "\"abcdefghijk ABCDEFGHIJK\"" , __gencode__ = {"gtk_font_selection_set_preview_text((GtkFontSelection*)({* id *}), (const gchar*)({* property.value *}))"} },
  },
  parent = Gtk324.GtkBox,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkFrame
Gtk324.GtkFrame = {
  class = "GtkFrame", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_frame_new((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    compute_child_allocation = {"void", {"GtkFrame*", "GtkAllocation*"}, {"frame", "allocation"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    label            = {__type__="gchar*"        ,__default__ = "NULL"                 , __gencode__ = {"gtk_frame_set_label((GtkFrame*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["label-widget"] = {__type__="GtkWidget*"                                          , __gencode__ = {"gtk_frame_set_label_widget((GtkFrame*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["label-xalign"] = {__type__="gfloat"        ,__default__ = "0"                    ,rwflags="rw" },
    ["label-yalign"] = {__type__="gfloat"        ,__default__ = "0.5"                  ,rwflags="rw" },
    ["shadow-type"]  = {__type__="GtkShadowType" ,__default__ = "GTK_SHADOW_ETCHED_IN" , __gencode__ = {"gtk_frame_set_shadow_type((GtkFrame*)({* id *}), (GtkShadowType)({* property.value *}))"} },
  },
  parent = Gtk324.GtkBin,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkFrameAccessible
Gtk324.GtkFrameAccessible = {
  class = "GtkFrameAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkContainerAccessible,
};

---------------------  GtkGestureDrag
Gtk324.GtkGestureDrag = {
  class = "GtkGestureDrag", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_gesture_drag_new((GtkWidget*)({* this.widget.value *}))", 
            params = { type = {"GtkWidget*"}, 
                       name = {"widget"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['drag-begin']  = {ret_type = "void", params = {type = {"GtkGestureDrag*", "gdouble", "gdouble"}, name ={"gesturedrag", "start_x", "start_y"}} }, 
    ['drag-end']    = {ret_type = "void", params = {type = {"GtkGestureDrag*", "gdouble", "gdouble"}, name ={"gesturedrag", "offset_x", "offset_y"}} }, 
    ['drag-update'] = {ret_type = "void", params = {type = {"GtkGestureDrag*", "gdouble", "gdouble"}, name ={"gesturedrag", "offset_x", "offset_y"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkGestureSingle,
};

---------------------  GtkGestureLongPress
Gtk324.GtkGestureLongPress = {
  class = "GtkGestureLongPress", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_gesture_long_press_new((GtkWidget*)({* this.widget.value *}))", 
            params = { type = {"GtkWidget*"}, 
                       name = {"widget"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    cancelled = {ret_type = "void", params = {type = {"GtkGestureLongPress*"}, name ={"gesturelongpress"}} }, 
    pressed   = {ret_type = "void", params = {type = {"GtkGestureLongPress*", "gdouble", "gdouble"}, name ={"gesturelongpress", "x", "y"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["delay-factor"] = {__type__="gdouble" ,__default__ = "1" ,rwflags="rw" },
  },
  parent = Gtk324.GtkGestureSingle,
};

---------------------  GtkGestureMultiPress
Gtk324.GtkGestureMultiPress = {
  class = "GtkGestureMultiPress", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_gesture_multi_press_new((GtkWidget*)({* this.widget.value *}))", 
            params = { type = {"GtkWidget*"}, 
                       name = {"widget"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    pressed  = {ret_type = "void", params = {type = {"GtkGestureMultiPress*", "gint", "gdouble", "gdouble"}, name ={"gesturemultipress", "n_press", "x", "y"}} }, 
    released = {ret_type = "void", params = {type = {"GtkGestureMultiPress*", "gint", "gdouble", "gdouble"}, name ={"gesturemultipress", "n_press", "x", "y"}} }, 
    stopped  = {ret_type = "void", params = {type = {"GtkGestureMultiPress*"}, name ={"gesturemultipress"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkGestureSingle,
};

---------------------  GtkGestureStylus
Gtk324.GtkGestureStylus = {
  class = "GtkGestureStylus", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_gesture_stylus_new((GtkWidget*)({* this.widget.value *}))", 
            params = { type = {"GtkWidget*"}, 
                       name = {"widget"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    down      = {ret_type = "void", params = {type = {"GtkGestureStylus*", "gdouble", "gdouble"}, name ={"gesturestylus", "object", "p0"}} }, 
    motion    = {ret_type = "void", params = {type = {"GtkGestureStylus*", "gdouble", "gdouble"}, name ={"gesturestylus", "object", "p0"}} }, 
    proximity = {ret_type = "void", params = {type = {"GtkGestureStylus*", "gdouble", "gdouble"}, name ={"gesturestylus", "object", "p0"}} }, 
    up        = {ret_type = "void", params = {type = {"GtkGestureStylus*", "gdouble", "gdouble"}, name ={"gesturestylus", "object", "p0"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkGestureSingle,
};

---------------------  GtkGestureSwipe
Gtk324.GtkGestureSwipe = {
  class = "GtkGestureSwipe", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_gesture_swipe_new((GtkWidget*)({* this.widget.value *}))", 
            params = { type = {"GtkWidget*"}, 
                       name = {"widget"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    swipe = {ret_type = "void", params = {type = {"GtkGestureSwipe*", "gdouble", "gdouble"}, name ={"gestureswipe", "velocity_x", "velocity_y"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkGestureSingle,
};

---------------------  GtkHBox
Gtk324.GtkHBox = {
  class = "GtkHBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_hbox_new((gboolean)({* this.homogeneous.value *}), (gint)({* this.spacing.value *}))", 
            params = { type = {"gboolean", "gint"}, 
                       name = {"homogeneous", "spacing"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkBox,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkHPaned
Gtk324.GtkHPaned = {
  class = "GtkHPaned", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_hpaned_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkPaned,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkHScale
Gtk324.GtkHScale = {
  class = "GtkHScale", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_hscale_new((GtkAdjustment*)({* this.adjustment.value *}))", 
            params = { type = {"GtkAdjustment*"}, 
                       name = {"adjustment"} } },
    new_with_range = { gencode = "gtk_hscale_new_with_range((gdouble)({* this.min.value *}), (gdouble)({* this.max.value *}), (gdouble)({* this.step.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkScale,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkHScrollbar
Gtk324.GtkHScrollbar = {
  class = "GtkHScrollbar", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_hscrollbar_new((GtkAdjustment*)({* this.adjustment.value *}))", 
            params = { type = {"GtkAdjustment*"}, 
                       name = {"adjustment"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkScrollbar,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkHandleBox
Gtk324.GtkHandleBox = {
  class = "GtkHandleBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_handle_box_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    child_attached = {"void", {"GtkHandleBox*", "GtkWidget*"}, {"handle_box", "child"} }, 
    child_detached = {"void", {"GtkHandleBox*", "GtkWidget*"}, {"handle_box", "child"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['child-attached'] = {ret_type = "void", params = {type = {"GtkHandleBox*", "GtkWidget*"}, name ={"handlebox", "widget"}} }, 
    ['child-detached'] = {ret_type = "void", params = {type = {"GtkHandleBox*", "GtkWidget*"}, name ={"handlebox", "widget"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["child-detached"]  = {__type__="gboolean"        ,__default__ = "FALSE"           },
    ["handle-position"] = {__type__="GtkPositionType" ,__default__ = "GTK_POS_LEFT"   , __gencode__ = {"gtk_handle_box_set_handle_position((GtkHandleBox*)({* id *}), (GtkPositionType)({* property.value *}))"} },
    ["shadow-type"]     = {__type__="GtkShadowType"   ,__default__ = "GTK_SHADOW_OUT" , __gencode__ = {"gtk_handle_box_set_shadow_type((GtkHandleBox*)({* id *}), (GtkShadowType)({* property.value *}))"} },
    ["snap-edge"]       = {__type__="GtkPositionType" ,__default__ = "GTK_POS_TOP"    , __gencode__ = {"gtk_handle_box_set_snap_edge((GtkHandleBox*)({* id *}), (GtkPositionType)({* property.value *}))"} },
    ["snap-edge-set"]   = {__type__="gboolean"        ,__default__ = "FALSE"          ,rwflags="rw" },
  },
  parent = Gtk324.GtkBin,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkHeaderBarAccessible
Gtk324.GtkHeaderBarAccessible = {
  class = "GtkHeaderBarAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkContainerAccessible,
};

---------------------  GtkIconViewAccessible
Gtk324.GtkIconViewAccessible = {
  class = "GtkIconViewAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkContainerAccessible,
};

---------------------  GtkImageCellAccessible
Gtk324.GtkImageCellAccessible = {
  class = "GtkImageCellAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkRendererCellAccessible,
};

---------------------  GtkInfoBar
Gtk324.GtkInfoBar = {
  class = "GtkInfoBar", 
  constructor = { 
    -- 名称[- ==> _], 
    new              = { gencode = "gtk_info_bar_new()", 
            params = { type = {}, name = {} } },
    new_with_buttons = { gencode = "gtk_info_bar_new_with_buttons((const gchar*)({* this.first_button_text.value *}), 0)", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    close    = {"void", {"GtkInfoBar*"}, {"info_bar"} }, 
    response = {"void", {"GtkInfoBar*", "gint"}, {"info_bar", "response_id"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    close    = {ret_type = "void", params = {type = {"GtkInfoBar*"}, name ={"info_bar"}} }, 
    response = {ret_type = "void", params = {type = {"GtkInfoBar*", "gint"}, name ={"info_bar", "response_id"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["message-type"]      = {__type__="GtkMessageType" ,__default__ = "GTK_MESSAGE_INFO" , __gencode__ = {"gtk_info_bar_set_message_type((GtkInfoBar*)({* id *}), (GtkMessageType)({* property.value *}))"},__construct__= 1 },
    revealed              = {__type__="gboolean"       ,__default__ = "TRUE"             , __gencode__ = {"gtk_info_bar_set_revealed((GtkInfoBar*)({* id *}), (gboolean)({* property.value *}))"} },
    ["show-close-button"] = {__type__="gboolean"       ,__default__ = "FALSE"            , __gencode__ = {"gtk_info_bar_set_show_close_button((GtkInfoBar*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
  },
  parent = Gtk324.GtkBox,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkListBoxAccessible
Gtk324.GtkListBoxAccessible = {
  class = "GtkListBoxAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkContainerAccessible,
};

---------------------  GtkListBoxRow
Gtk324.GtkListBoxRow = {
  class = "GtkListBoxRow", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_list_box_row_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate = {"void", {"GtkListBoxRow*"}, {"row"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate = {ret_type = "void", params = {type = {"GtkListBoxRow*"}, name ={"row"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    activatable = {__type__="gboolean" ,__default__ = "TRUE" , __gencode__ = {"gtk_list_box_row_set_activatable((GtkListBoxRow*)({* id *}), (gboolean)({* property.value *}))"} },
    selectable  = {__type__="gboolean" ,__default__ = "TRUE" , __gencode__ = {"gtk_list_box_row_set_selectable((GtkListBoxRow*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk324.GtkBin,
  implement = {Gtk324.GtkActionable, Gtk324.GtkBuildable}, 
};

---------------------  GtkListBoxRowAccessible
Gtk324.GtkListBoxRowAccessible = {
  class = "GtkListBoxRowAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkContainerAccessible,
};

---------------------  GtkMenu
Gtk324.GtkMenu = {
  class = "GtkMenu", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_menu_new()", 
            params = { type = {}, name = {} } },
    new_from_model = { gencode = "gtk_menu_new_from_model((GMenuModel*)({* this.model.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['move-scroll'] = {ret_type = "void", params = {type = {"GtkMenu*", "GtkScrollType"}, name ={"menu", "scroll_type"}} }, 
    ['popped-up']   = {ret_type = "void", params = {type = {"GtkMenu*", "gpointer", "gpointer", "gboolean", "gboolean"}, name ={"menu", "flipped_rect", "final_rect", "flipped_x", "flipped_y"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["accel-group"]         = {__type__="GtkAccelGroup*"                                                                                                                                                 , __gencode__ = {"gtk_menu_set_accel_group((GtkMenu*)({* id *}), (GtkAccelGroup*)({* property.value *}))"} },
    ["accel-path"]          = {__type__="gchar*"            ,__default__ = "NULL"                                                                                                                        , __gencode__ = {"gtk_menu_set_accel_path((GtkMenu*)({* id *}), (const gchar*)({* property.value *}))"} },
    active                  = {__type__="gint"              ,__default__ = "-1"                                                                                                                          , __gencode__ = {"gtk_menu_set_active((GtkMenu*)({* id *}), (guint)({* property.value *}))"} },
    ["anchor-hints"]        = {__type__="GdkAnchorHints"    ,__default__ = "GDK_ANCHOR_FLIP_X | GDK_ANCHOR_FLIP_Y | GDK_ANCHOR_SLIDE_X | GDK_ANCHOR_SLIDE_Y | GDK_ANCHOR_RESIZE_X | GDK_ANCHOR_RESIZE_Y" ,rwflags="rw",__construct__= 1 },
    ["attach-widget"]       = {__type__="GtkWidget*"                                                                                                                                                     ,rwflags="rw" },
    ["menu-type-hint"]      = {__type__="GdkWindowTypeHint" ,__default__ = "GDK_WINDOW_TYPE_HINT_POPUP_MENU"                                                                                             ,rwflags="rw",__construct__= 1 },
    monitor                 = {__type__="gint"              ,__default__ = "-1"                                                                                                                          , __gencode__ = {"gtk_menu_set_monitor((GtkMenu*)({* id *}), (gint)({* property.value *}))"} },
    ["rect-anchor-dx"]      = {__type__="gint"              ,__default__ = "0"                                                                                                                           ,rwflags="rw",__construct__= 1 },
    ["rect-anchor-dy"]      = {__type__="gint"              ,__default__ = "0"                                                                                                                           ,rwflags="rw",__construct__= 1 },
    ["reserve-toggle-size"] = {__type__="gboolean"          ,__default__ = "TRUE"                                                                                                                        , __gencode__ = {"gtk_menu_set_reserve_toggle_size((GtkMenu*)({* id *}), (gboolean)({* property.value *}))"} },
    ["tearoff-state"]       = {__type__="gboolean"          ,__default__ = "FALSE"                                                                                                                       , __gencode__ = {"gtk_menu_set_tearoff_state((GtkMenu*)({* id *}), (gboolean)({* property.value *}))"} },
    ["tearoff-title"]       = {__type__="gchar*"            ,__default__ = "NULL"                                                                                                                        ,rwflags="rw" },
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    ["bottom-attach"] = {__type__="gint" ,__default__ = "-1" },
    ["left-attach"]   = {__type__="gint" ,__default__ = "-1" },
    ["right-attach"]  = {__type__="gint" ,__default__ = "-1" },
    ["top-attach"]    = {__type__="gint" ,__default__ = "-1" },
  },
  parent = Gtk324.GtkMenuShell,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkMenuBar
Gtk324.GtkMenuBar = {
  class = "GtkMenuBar", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_menu_bar_new()", 
            params = { type = {}, name = {} } },
    new_from_model = { gencode = "gtk_menu_bar_new_from_model((GMenuModel*)({* this.model.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["child-pack-direction"] = {__type__="GtkPackDirection" ,__default__ = "GTK_PACK_DIRECTION_LTR" , __gencode__ = {"gtk_menu_bar_set_child_pack_direction((GtkMenuBar*)({* id *}), (GtkPackDirection)({* property.value *}))"} },
    ["pack-direction"]       = {__type__="GtkPackDirection" ,__default__ = "GTK_PACK_DIRECTION_LTR" , __gencode__ = {"gtk_menu_bar_set_pack_direction((GtkMenuBar*)({* id *}), (GtkPackDirection)({* property.value *}))"} },
  },
  parent = Gtk324.GtkMenuShell,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkMenuItem
Gtk324.GtkMenuItem = {
  class = "GtkMenuItem", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_menu_item_new()", 
            params = { type = {}, name = {} } },
    new_with_label    = { gencode = "gtk_menu_item_new_with_label((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
    new_with_mnemonic = { gencode = "gtk_menu_item_new_with_mnemonic((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate             = {"void"        , {"GtkMenuItem*"}, {"menu_item"} }, 
    activate_item        = {"void"        , {"GtkMenuItem*"}, {"menu_item"} }, 
    deselect             = {"void"        , {"GtkMenuItem*"}, {"menu_item"} }, 
    get_label            = {"const gchar*", {"GtkMenuItem*"}, {"menu_item"} }, 
    select               = {"void"        , {"GtkMenuItem*"}, {"menu_item"} }, 
    set_label            = {"void"        , {"GtkMenuItem*", "const gchar*"}, {"menu_item", "label"} }, 
    toggle_size_allocate = {"void"        , {"GtkMenuItem*", "gint"}, {"menu_item", "allocation"} }, 
    toggle_size_request  = {"void"        , {"GtkMenuItem*", "gint*"}, {"menu_item", "requisition"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    activate                 = {ret_type = "void", params = {type = {"GtkMenuItem*"}, name ={"menu_item"}} }, 
    ['activate-item']        = {ret_type = "void", params = {type = {"GtkMenuItem*"}, name ={"menuitem"}} }, 
    deselect                 = {ret_type = "void", params = {type = {"GtkMenuItem*"}, name ={"menu_item"}} }, 
    select                   = {ret_type = "void", params = {type = {"GtkMenuItem*"}, name ={"menu_item"}} }, 
    ['toggle-size-allocate'] = {ret_type = "void", params = {type = {"GtkMenuItem*", "gint"}, name ={"menuitem", "object"}} }, 
    ['toggle-size-request']  = {ret_type = "void", params = {type = {"GtkMenuItem*", "gpointer"}, name ={"menuitem", "object"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["accel-path"]      = {__type__="gchar*"   ,__default__ = "NULL"  , __gencode__ = {"gtk_menu_item_set_accel_path((GtkMenuItem*)({* id *}), (const gchar*)({* property.value *}))"} },
    label               = {__type__="gchar*"   ,__default__ = "\"\""  , __gencode__ = {"gtk_menu_item_set_label((GtkMenuItem*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["right-justified"] = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_menu_item_set_right_justified((GtkMenuItem*)({* id *}), (gboolean)({* property.value *}))"} },
    submenu             = {__type__="GtkMenu*"                        , __gencode__ = {"gtk_menu_item_set_submenu((GtkMenuItem*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["use-underline"]   = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_menu_item_set_use_underline((GtkMenuItem*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk324.GtkBin,
  implement = {Gtk324.GtkActionable, Gtk324.GtkActivatable, Gtk324.GtkBuildable}, 
};

---------------------  GtkMenuItemAccessible
Gtk324.GtkMenuItemAccessible = {
  class = "GtkMenuItemAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkContainerAccessible,
};

---------------------  GtkMenuShellAccessible
Gtk324.GtkMenuShellAccessible = {
  class = "GtkMenuShellAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkContainerAccessible,
};

---------------------  GtkNotebookAccessible
Gtk324.GtkNotebookAccessible = {
  class = "GtkNotebookAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkContainerAccessible,
};

---------------------  GtkOverlay
Gtk324.GtkOverlay = {
  class = "GtkOverlay", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_overlay_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    get_child_position = {"gboolean", {"GtkOverlay*", "GtkWidget*", "GtkAllocation*"}, {"overlay", "widget", "allocation"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['get-child-position'] = {ret_type = "gboolean", params = {type = {"GtkOverlay*", "GtkWidget*", "GdkRectangle*"}, name ={"overlay", "widget", "allocation"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    index            = {__type__="gint"     ,__default__ = "0" },
    ["pass-through"] = {__type__="gboolean" ,__default__ = "FALSE" },
  },
  parent = Gtk324.GtkBin,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkPanedAccessible
Gtk324.GtkPanedAccessible = {
  class = "GtkPanedAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkContainerAccessible,
};

---------------------  GtkPopover
Gtk324.GtkPopover = {
  class = "GtkPopover", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_popover_new((GtkWidget*)({* this['relative-to']value *}))", 
            params = { type = {"GtkWidget*"}, 
                       name = {"relative-to"} } },
    new_from_model = { gencode = "gtk_popover_new_from_model((GtkWidget*)({* this['relative-to']value *}), (GMenuModel*)({* this.model.value *}))", 
            params = { type = {"GtkWidget*"}, 
                       name = {"relative-to"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    closed = {"void", {"GtkPopover*"}, {"popover"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    closed = {ret_type = "void", params = {type = {"GtkPopover*"}, name ={"popover"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["constrain-to"]        = {__type__="GtkPopoverConstraint" ,__default__ = "GTK_POPOVER_CONSTRAINT_WINDOW" , __gencode__ = {"gtk_popover_set_constrain_to((GtkPopover*)({* id *}), (GtkPopoverConstraint)({* property.value *}))"} },
    modal                   = {__type__="gboolean"             ,__default__ = "TRUE"                          , __gencode__ = {"gtk_popover_set_modal((GtkPopover*)({* id *}), (gboolean)({* property.value *}))"} },
    ["pointing-to"]         = {__type__="GdkRectangle*"                                                       , __gencode__ = {"gtk_popover_set_pointing_to((GtkPopover*)({* id *}), (const GdkRectangle*)({* property.value *}))"} },
    position                = {__type__="GtkPositionType"      ,__default__ = "GTK_POS_TOP"                   , __gencode__ = {"gtk_popover_set_position((GtkPopover*)({* id *}), (GtkPositionType)({* property.value *}))"} },
    ["relative-to"]         = {__type__="GtkWidget*"                                                          , __gencode__ = {"gtk_popover_set_relative_to((GtkPopover*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["transitions-enabled"] = {__type__="gboolean"             ,__default__ = "TRUE"                          , __gencode__ = {"gtk_popover_set_transitions_enabled((GtkPopover*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk324.GtkBin,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkPopoverAccessible
Gtk324.GtkPopoverAccessible = {
  class = "GtkPopoverAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkContainerAccessible,
};

---------------------  GtkRecentChooserWidget
Gtk324.GtkRecentChooserWidget = {
  class = "GtkRecentChooserWidget", 
  constructor = { 
    -- 名称[- ==> _], 
    new             = { gencode = "gtk_recent_chooser_widget_new()", 
            params = { type = {}, name = {} } },
    new_for_manager = { gencode = "gtk_recent_chooser_widget_new_for_manager((GtkRecentManager*)({* this.manager.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkBox,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable, Gtk324.GtkRecentChooser}, 
};

---------------------  GtkRevealer
Gtk324.GtkRevealer = {
  class = "GtkRevealer", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_revealer_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["child-revealed"]      = {__type__="gboolean"                  ,__default__ = "FALSE"                                    },
    ["reveal-child"]        = {__type__="gboolean"                  ,__default__ = "FALSE"                                   , __gencode__ = {"gtk_revealer_set_reveal_child((GtkRevealer*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    ["transition-duration"] = {__type__="guint"                     ,__default__ = "250"                                     , __gencode__ = {"gtk_revealer_set_transition_duration((GtkRevealer*)({* id *}), (guint)({* property.value *}))"},__construct__= 1 },
    ["transition-type"]     = {__type__="GtkRevealerTransitionType" ,__default__ = "GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN" , __gencode__ = {"gtk_revealer_set_transition_type((GtkRevealer*)({* id *}), (GtkRevealerTransitionType)({* property.value *}))"},__construct__= 1 },
  },
  parent = Gtk324.GtkBin,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkScaleAccessible
Gtk324.GtkScaleAccessible = {
  class = "GtkScaleAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkRangeAccessible,
};

---------------------  GtkScrolledWindow
Gtk324.GtkScrolledWindow = {
  class = "GtkScrolledWindow", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_scrolled_window_new((GtkAdjustment*)({* this.hadjustment.value *}), (GtkAdjustment*)({* this.vadjustment.value *}))", 
            params = { type = {"GtkAdjustment*", "GtkAdjustment*"}, 
                       name = {"hadjustment", "vadjustment"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    move_focus_out = {"void"    , {"GtkScrolledWindow*", "GtkDirectionType"}, {"scrolled_window", "direction"} }, 
    scroll_child   = {"gboolean", {"GtkScrolledWindow*", "GtkScrollType", "gboolean"}, {"scrolled_window", "scroll", "horizontal"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['edge-overshot']  = {ret_type = "void"    , params = {type = {"GtkScrolledWindow*", "GtkPositionType"}, name ={"scrolledwindow", "pos"}} }, 
    ['edge-reached']   = {ret_type = "void"    , params = {type = {"GtkScrolledWindow*", "GtkPositionType"}, name ={"scrolledwindow", "pos"}} }, 
    ['move-focus-out'] = {ret_type = "void"    , params = {type = {"GtkScrolledWindow*", "GtkDirectionType"}, name ={"scrolledwindow", "direction_type"}} }, 
    ['scroll-child']   = {ret_type = "gboolean", params = {type = {"GtkScrolledWindow*", "GtkScrollType", "gboolean"}, name ={"scrolledwindow", "scroll", "horizontal"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    hadjustment                  = {__type__="GtkAdjustment*"                                       , __gencode__ = {"gtk_scrolled_window_set_hadjustment((GtkScrolledWindow*)({* id *}), (GtkAdjustment*)({* property.value *}))"},__construct__= 1 },
    ["hscrollbar-policy"]        = {__type__="GtkPolicyType"  ,__default__ = "GTK_POLICY_AUTOMATIC" ,rwflags="rw" },
    ["kinetic-scrolling"]        = {__type__="gboolean"       ,__default__ = "TRUE"                 , __gencode__ = {"gtk_scrolled_window_set_kinetic_scrolling((GtkScrolledWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    ["max-content-height"]       = {__type__="gint"           ,__default__ = "-1"                   , __gencode__ = {"gtk_scrolled_window_set_max_content_height((GtkScrolledWindow*)({* id *}), (gint)({* property.value *}))"} },
    ["max-content-width"]        = {__type__="gint"           ,__default__ = "-1"                   , __gencode__ = {"gtk_scrolled_window_set_max_content_width((GtkScrolledWindow*)({* id *}), (gint)({* property.value *}))"} },
    ["min-content-height"]       = {__type__="gint"           ,__default__ = "-1"                   , __gencode__ = {"gtk_scrolled_window_set_min_content_height((GtkScrolledWindow*)({* id *}), (gint)({* property.value *}))"} },
    ["min-content-width"]        = {__type__="gint"           ,__default__ = "-1"                   , __gencode__ = {"gtk_scrolled_window_set_min_content_width((GtkScrolledWindow*)({* id *}), (gint)({* property.value *}))"} },
    ["overlay-scrolling"]        = {__type__="gboolean"       ,__default__ = "TRUE"                 , __gencode__ = {"gtk_scrolled_window_set_overlay_scrolling((GtkScrolledWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    ["propagate-natural-height"] = {__type__="gboolean"       ,__default__ = "FALSE"                , __gencode__ = {"gtk_scrolled_window_set_propagate_natural_height((GtkScrolledWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    ["propagate-natural-width"]  = {__type__="gboolean"       ,__default__ = "FALSE"                , __gencode__ = {"gtk_scrolled_window_set_propagate_natural_width((GtkScrolledWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    ["shadow-type"]              = {__type__="GtkShadowType"  ,__default__ = "GTK_SHADOW_NONE"      , __gencode__ = {"gtk_scrolled_window_set_shadow_type((GtkScrolledWindow*)({* id *}), (GtkShadowType)({* property.value *}))"} },
    vadjustment                  = {__type__="GtkAdjustment*"                                       , __gencode__ = {"gtk_scrolled_window_set_vadjustment((GtkScrolledWindow*)({* id *}), (GtkAdjustment*)({* property.value *}))"},__construct__= 1 },
    ["vscrollbar-policy"]        = {__type__="GtkPolicyType"  ,__default__ = "GTK_POLICY_AUTOMATIC" ,rwflags="rw" },
    ["window-placement"]         = {__type__="GtkCornerType"  ,__default__ = "GTK_CORNER_TOP_LEFT"  ,rwflags="rw" },
    ["window-placement-set"]     = {__type__="gboolean"       ,__default__ = "TRUE"                 ,rwflags="rw" },
  },
  parent = Gtk324.GtkBin,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkScrolledWindowAccessible
Gtk324.GtkScrolledWindowAccessible = {
  class = "GtkScrolledWindowAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkContainerAccessible,
};

---------------------  GtkSearchBar
Gtk324.GtkSearchBar = {
  class = "GtkSearchBar", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_search_bar_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["search-mode-enabled"] = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
    ["show-close-button"]   = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_search_bar_set_show_close_button((GtkSearchBar*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
  },
  parent = Gtk324.GtkBin,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkShortcutLabel
Gtk324.GtkShortcutLabel = {
  class = "GtkShortcutLabel", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_shortcut_label_new((const gchar*)({* this.accelerator.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"accelerator"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    accelerator       = {__type__="gchar*" ,__default__ = "NULL" , __gencode__ = {"gtk_shortcut_label_set_accelerator((GtkShortcutLabel*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["disabled-text"] = {__type__="gchar*" ,__default__ = "NULL" , __gencode__ = {"gtk_shortcut_label_set_disabled_text((GtkShortcutLabel*)({* id *}), (const gchar*)({* property.value *}))"} },
  },
  parent = Gtk324.GtkBox,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkShortcutsGroup
Gtk324.GtkShortcutsGroup = {
  class = "GtkShortcutsGroup", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["accel-size-group"] = {__type__="GtkSizeGroup*"                       ,rwflags="w" },
    height               = {__type__="guint"         ,__default__ = "1"     },
    title                = {__type__="gchar*"        ,__default__ = "\"\"" ,rwflags="rw" },
    ["title-size-group"] = {__type__="GtkSizeGroup*"                       ,rwflags="w" },
    view                 = {__type__="gchar*"        ,__default__ = "NULL" ,rwflags="rw" },
  },
  parent = Gtk324.GtkBox,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkShortcutsSection
Gtk324.GtkShortcutsSection = {
  class = "GtkShortcutsSection", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['change-current-page'] = {ret_type = "gboolean", params = {type = {"GtkShortcutsSection*", "gint"}, name ={"shortcutssection", "object"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["max-height"]   = {__type__="guint"  ,__default__ = "15"   ,rwflags="rw" },
    ["section-name"] = {__type__="gchar*" ,__default__ = "NULL" ,rwflags="rw" },
    title            = {__type__="gchar*" ,__default__ = "NULL" ,rwflags="rw" },
    ["view-name"]    = {__type__="gchar*" ,__default__ = "NULL" ,rwflags="rw" },
  },
  parent = Gtk324.GtkBox,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkShortcutsShortcut
Gtk324.GtkShortcutsShortcut = {
  class = "GtkShortcutsShortcut", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["accel-size-group"] = {__type__="GtkSizeGroup*"                                              ,rwflags="w" },
    accelerator          = {__type__="gchar*"           ,__default__ = "NULL"                     ,rwflags="rw" },
    ["action-name"]      = {__type__="gchar*"           ,__default__ = "NULL"                     ,rwflags="rw" },
    direction            = {__type__="GtkTextDirection" ,__default__ = "GTK_TEXT_DIR_NONE"        ,rwflags="rw" },
    icon                 = {__type__="GIcon*"                                                     ,rwflags="rw" },
    ["icon-set"]         = {__type__="gboolean"         ,__default__ = "FALSE"                    ,rwflags="rw" },
    ["shortcut-type"]    = {__type__="GtkShortcutType"  ,__default__ = "GTK_SHORTCUT_ACCELERATOR" ,rwflags="rw" },
    subtitle             = {__type__="gchar*"           ,__default__ = "\"\""                     ,rwflags="rw" },
    ["subtitle-set"]     = {__type__="gboolean"         ,__default__ = "FALSE"                    ,rwflags="rw" },
    title                = {__type__="gchar*"           ,__default__ = "\"\""                     ,rwflags="rw" },
    ["title-size-group"] = {__type__="GtkSizeGroup*"                                              ,rwflags="w" },
  },
  parent = Gtk324.GtkBox,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkSocketAccessible
Gtk324.GtkSocketAccessible = {
  class = "GtkSocketAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkContainerAccessible,
};

---------------------  GtkSpinButtonAccessible
Gtk324.GtkSpinButtonAccessible = {
  class = "GtkSpinButtonAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkEntryAccessible,
};

---------------------  GtkStackAccessible
Gtk324.GtkStackAccessible = {
  class = "GtkStackAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkContainerAccessible,
};

---------------------  GtkStackSidebar
Gtk324.GtkStackSidebar = {
  class = "GtkStackSidebar", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_stack_sidebar_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    stack = {__type__="GtkStack*" , __gencode__ = {"gtk_stack_sidebar_set_stack((GtkStackSidebar*)({* id *}), (GtkStack*)({* property.value *}))"} },
  },
  parent = Gtk324.GtkBin,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkStackSwitcher
Gtk324.GtkStackSwitcher = {
  class = "GtkStackSwitcher", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_stack_switcher_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["icon-size"] = {__type__="gint"      ,__default__ = "1" ,rwflags="rw" },
    stack         = {__type__="GtkStack*"                    , __gencode__ = {"gtk_stack_switcher_set_stack((GtkStackSwitcher*)({* id *}), (GtkStack*)({* property.value *}))"},__construct__= 1 },
  },
  parent = Gtk324.GtkBox,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkStatusbar
Gtk324.GtkStatusbar = {
  class = "GtkStatusbar", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_statusbar_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    text_popped = {"void", {"GtkStatusbar*", "guint", "const gchar*"}, {"statusbar", "context_id", "text"} }, 
    text_pushed = {"void", {"GtkStatusbar*", "guint", "const gchar*"}, {"statusbar", "context_id", "text"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['text-popped'] = {ret_type = "void", params = {type = {"GtkStatusbar*", "guint", "gchar*"}, name ={"statusbar", "context_id", "text"}} }, 
    ['text-pushed'] = {ret_type = "void", params = {type = {"GtkStatusbar*", "guint", "gchar*"}, name ={"statusbar", "context_id", "text"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkBox,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkStatusbarAccessible
Gtk324.GtkStatusbarAccessible = {
  class = "GtkStatusbarAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkContainerAccessible,
};

---------------------  GtkTextCellAccessible
Gtk324.GtkTextCellAccessible = {
  class = "GtkTextCellAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkRendererCellAccessible,
};

---------------------  GtkTextViewAccessible
Gtk324.GtkTextViewAccessible = {
  class = "GtkTextViewAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkContainerAccessible,
};

---------------------  GtkToolItem
Gtk324.GtkToolItem = {
  class = "GtkToolItem", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_tool_item_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    create_menu_proxy    = {"gboolean", {"GtkToolItem*"}, {"tool_item"} }, 
    toolbar_reconfigured = {"void"    , {"GtkToolItem*"}, {"tool_item"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['create-menu-proxy']    = {ret_type = "gboolean", params = {type = {"GtkToolItem*"}, name ={"toolitem"}} }, 
    ['toolbar-reconfigured'] = {ret_type = "void"    , params = {type = {"GtkToolItem*"}, name ={"toolitem"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["is-important"]       = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_tool_item_set_is_important((GtkToolItem*)({* id *}), (gboolean)({* property.value *}))"} },
    ["visible-horizontal"] = {__type__="gboolean" ,__default__ = "TRUE"  , __gencode__ = {"gtk_tool_item_set_visible_horizontal((GtkToolItem*)({* id *}), (gboolean)({* property.value *}))"} },
    ["visible-vertical"]   = {__type__="gboolean" ,__default__ = "TRUE"  , __gencode__ = {"gtk_tool_item_set_visible_vertical((GtkToolItem*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk324.GtkBin,
  implement = {Gtk324.GtkActivatable, Gtk324.GtkBuildable}, 
};

---------------------  GtkTreeViewAccessible
Gtk324.GtkTreeViewAccessible = {
  class = "GtkTreeViewAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkContainerAccessible,
  implement = {Gtk324.GtkCellAccessibleParent}, 
};

---------------------  GtkVBox
Gtk324.GtkVBox = {
  class = "GtkVBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_vbox_new((gboolean)({* this.homogeneous.value *}), (gint)({* this.spacing.value *}))", 
            params = { type = {"gboolean", "gint"}, 
                       name = {"homogeneous", "spacing"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkBox,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkVPaned
Gtk324.GtkVPaned = {
  class = "GtkVPaned", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_vpaned_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkPaned,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkVScale
Gtk324.GtkVScale = {
  class = "GtkVScale", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_vscale_new((GtkAdjustment*)({* this.adjustment.value *}))", 
            params = { type = {"GtkAdjustment*"}, 
                       name = {"adjustment"} } },
    new_with_range = { gencode = "gtk_vscale_new_with_range((gdouble)({* this.min.value *}), (gdouble)({* this.max.value *}), (gdouble)({* this.step.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkScale,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkVScrollbar
Gtk324.GtkVScrollbar = {
  class = "GtkVScrollbar", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_vscrollbar_new((GtkAdjustment*)({* this.adjustment.value *}))", 
            params = { type = {"GtkAdjustment*"}, 
                       name = {"adjustment"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkScrollbar,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkViewport
Gtk324.GtkViewport = {
  class = "GtkViewport", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_viewport_new((GtkAdjustment*)({* this.hadjustment.value *}), (GtkAdjustment*)({* this.vadjustment.value *}))", 
            params = { type = {"GtkAdjustment*", "GtkAdjustment*"}, 
                       name = {"hadjustment", "vadjustment"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["shadow-type"] = {__type__="GtkShadowType" ,__default__ = "GTK_SHADOW_IN" , __gencode__ = {"gtk_viewport_set_shadow_type((GtkViewport*)({* id *}), (GtkShadowType)({* property.value *}))"} },
  },
  parent = Gtk324.GtkBin,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkScrollable}, 
};

---------------------  GtkWindow
Gtk324.GtkWindow = {
  class = "GtkWindow", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_window_new((GtkWindowType)({* this.type.value *}))", 
            params = { type = {"GtkWindowType"}, 
                       name = {"type"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate_default = {"void"    , {"GtkWindow*"}, {"window"} }, 
    activate_focus   = {"void"    , {"GtkWindow*"}, {"window"} }, 
    enable_debugging = {"gboolean", {"GtkWindow*", "gboolean"}, {"window", "toggle"} }, 
    keys_changed     = {"void"    , {"GtkWindow*"}, {"window"} }, 
    set_focus        = {"void"    , {"GtkWindow*", "GtkWidget*"}, {"window", "focus"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['activate-default'] = {ret_type = "void"    , params = {type = {"GtkWindow*"}, name ={"window"}} }, 
    ['activate-focus']   = {ret_type = "void"    , params = {type = {"GtkWindow*"}, name ={"window"}} }, 
    ['enable-debugging'] = {ret_type = "gboolean", params = {type = {"GtkWindow*", "gboolean"}, name ={"window", "toggle"}} }, 
    ['keys-changed']     = {ret_type = "void"    , params = {type = {"GtkWindow*"}, name ={"window"}} }, 
    ['set-focus']        = {ret_type = "void"    , params = {type = {"GtkWindow*", "GtkWidget*"}, name ={"window", "widget"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["accept-focus"]                 = {__type__="gboolean"          ,__default__ = "TRUE"                        , __gencode__ = {"gtk_window_set_accept_focus((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    application                      = {__type__="GtkApplication*"                                                , __gencode__ = {"gtk_window_set_application((GtkWindow*)({* id *}), (GtkApplication*)({* property.value *}))"} },
    ["attached-to"]                  = {__type__="GtkWidget*"                                                     , __gencode__ = {"gtk_window_set_attached_to((GtkWindow*)({* id *}), (GtkWidget*)({* property.value *}))"},__construct__= 1 },
    decorated                        = {__type__="gboolean"          ,__default__ = "TRUE"                        , __gencode__ = {"gtk_window_set_decorated((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    ["default-height"]               = {__type__="gint"              ,__default__ = "-1"                          ,rwflags="rw" },
    ["default-width"]                = {__type__="gint"              ,__default__ = "-1"                          ,rwflags="rw" },
    deletable                        = {__type__="gboolean"          ,__default__ = "TRUE"                        , __gencode__ = {"gtk_window_set_deletable((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    ["destroy-with-parent"]          = {__type__="gboolean"          ,__default__ = "FALSE"                       , __gencode__ = {"gtk_window_set_destroy_with_parent((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    ["focus-on-map"]                 = {__type__="gboolean"          ,__default__ = "TRUE"                        , __gencode__ = {"gtk_window_set_focus_on_map((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    ["focus-visible"]                = {__type__="gboolean"          ,__default__ = "TRUE"                        , __gencode__ = {"gtk_window_set_focus_visible((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    gravity                          = {__type__="GdkGravity"        ,__default__ = "GDK_GRAVITY_NORTH_WEST"      , __gencode__ = {"gtk_window_set_gravity((GtkWindow*)({* id *}), (GdkGravity)({* property.value *}))"} },
    ["has-resize-grip"]              = {__type__="gboolean"          ,__default__ = "FALSE"                       , __gencode__ = {"gtk_window_set_has_resize_grip((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    ["has-toplevel-focus"]           = {__type__="gboolean"          ,__default__ = "FALSE"                        },
    ["hide-titlebar-when-maximized"] = {__type__="gboolean"          ,__default__ = "FALSE"                       , __gencode__ = {"gtk_window_set_hide_titlebar_when_maximized((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    icon                             = {__type__="GdkPixbuf*"                                                     , __gencode__ = {"gtk_window_set_icon((GtkWindow*)({* id *}), (GdkPixbuf*)({* property.value *}))"} },
    ["icon-name"]                    = {__type__="gchar*"            ,__default__ = "NULL"                        , __gencode__ = {"gtk_window_set_icon_name((GtkWindow*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["is-active"]                    = {__type__="gboolean"          ,__default__ = "FALSE"                        },
    ["is-maximized"]                 = {__type__="gboolean"          ,__default__ = "FALSE"                        },
    ["mnemonics-visible"]            = {__type__="gboolean"          ,__default__ = "TRUE"                        , __gencode__ = {"gtk_window_set_mnemonics_visible((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    modal                            = {__type__="gboolean"          ,__default__ = "FALSE"                       , __gencode__ = {"gtk_window_set_modal((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    resizable                        = {__type__="gboolean"          ,__default__ = "TRUE"                        , __gencode__ = {"gtk_window_set_resizable((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    ["resize-grip-visible"]          = {__type__="gboolean"          ,__default__ = "FALSE"                        },
    role                             = {__type__="gchar*"            ,__default__ = "NULL"                        , __gencode__ = {"gtk_window_set_role((GtkWindow*)({* id *}), (const gchar*)({* property.value *}))"} },
    screen                           = {__type__="GdkScreen*"                                                     , __gencode__ = {"gtk_window_set_screen((GtkWindow*)({* id *}), (GdkScreen*)({* property.value *}))"} },
    ["skip-pager-hint"]              = {__type__="gboolean"          ,__default__ = "FALSE"                       , __gencode__ = {"gtk_window_set_skip_pager_hint((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    ["skip-taskbar-hint"]            = {__type__="gboolean"          ,__default__ = "FALSE"                       , __gencode__ = {"gtk_window_set_skip_taskbar_hint((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    ["startup-id"]                   = {__type__="gchar*"            ,__default__ = "NULL"                        , __gencode__ = {"gtk_window_set_startup_id((GtkWindow*)({* id *}), (const gchar*)({* property.value *}))"} },
    title                            = {__type__="gchar*"            ,__default__ = "NULL"                        , __gencode__ = {"gtk_window_set_title((GtkWindow*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["transient-for"]                = {__type__="GtkWindow*"                                                     , __gencode__ = {"gtk_window_set_transient_for((GtkWindow*)({* id *}), (GtkWindow*)({* property.value *}))"},__construct__= 1 },
    type                             = {__type__="GtkWindowType"     ,__default__ = "GTK_WINDOW_TOPLEVEL"         ,rwflags="rw" },
    ["type-hint"]                    = {__type__="GdkWindowTypeHint" ,__default__ = "GDK_WINDOW_TYPE_HINT_NORMAL" , __gencode__ = {"gtk_window_set_type_hint((GtkWindow*)({* id *}), (GdkWindowTypeHint)({* property.value *}))"} },
    ["urgency-hint"]                 = {__type__="gboolean"          ,__default__ = "FALSE"                       , __gencode__ = {"gtk_window_set_urgency_hint((GtkWindow*)({* id *}), (gboolean)({* property.value *}))"} },
    ["window-position"]              = {__type__="GtkWindowPosition" ,__default__ = "GTK_WIN_POS_NONE"            ,rwflags="rw" },
  },
  parent = Gtk324.GtkBin,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkWindowAccessible
Gtk324.GtkWindowAccessible = {
  class = "GtkWindowAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkContainerAccessible,
};

---------------------  GtkAppChooserButton
Gtk324.GtkAppChooserButton = {
  class = "GtkAppChooserButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_app_chooser_button_new((const gchar*)({* this['content-type']value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"content-type"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    custom_item_activated = {"void", {"GtkAppChooserButton*", "const gchar*"}, {"self", "item_name"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['custom-item-activated'] = {ret_type = "void", params = {type = {"GtkAppChooserButton*", "gchar*"}, name ={"appchooserbutton", "item_name"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    heading               = {__type__="gchar*"   ,__default__ = "NULL"  , __gencode__ = {"gtk_app_chooser_button_set_heading((GtkAppChooserButton*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["show-default-item"] = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_app_chooser_button_set_show_default_item((GtkAppChooserButton*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    ["show-dialog-item"]  = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_app_chooser_button_set_show_dialog_item((GtkAppChooserButton*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
  },
  parent = Gtk324.GtkComboBox,
  implement = {Gtk324.GtkAppChooser, Gtk324.GtkBuildable, Gtk324.GtkCellEditable, Gtk324.GtkCellLayout}, 
};

---------------------  GtkApplicationWindow
Gtk324.GtkApplicationWindow = {
  class = "GtkApplicationWindow", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_application_window_new((GtkApplication*)({* this.application.value *}))", 
            params = { type = {"GtkApplication*"}, 
                       name = {"application"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["show-menubar"] = {__type__="gboolean" ,__default__ = "TRUE" , __gencode__ = {"gtk_application_window_set_show_menubar((GtkApplicationWindow*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
  },
  parent = Gtk324.GtkWindow,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkAspectFrame
Gtk324.GtkAspectFrame = {
  class = "GtkAspectFrame", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_aspect_frame_new((const gchar*)({* this.label.value *}), (gfloat)({* this.xalign.value *}), (gfloat)({* this.yalign.value *}), (gfloat)({* this.ratio.value *}), (gboolean)({* this['obey-child'].value *}))", 
            params = { type = {"const gchar*", "gfloat", "gfloat", "gfloat", "gboolean"}, 
                       name = {"label", "xalign", "yalign", "ratio", "obey-child"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["obey-child"] = {__type__="gboolean" ,__default__ = "TRUE" ,rwflags="rw" },
    ratio          = {__type__="gfloat"   ,__default__ = "1"    ,rwflags="rw" },
    xalign         = {__type__="gfloat"   ,__default__ = "0.5"  ,rwflags="rw" },
    yalign         = {__type__="gfloat"   ,__default__ = "0.5"  ,rwflags="rw" },
  },
  parent = Gtk324.GtkFrame,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkAssistant
Gtk324.GtkAssistant = {
  class = "GtkAssistant", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_assistant_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    apply   = {"void", {"GtkAssistant*"}, {"assistant"} }, 
    cancel  = {"void", {"GtkAssistant*"}, {"assistant"} }, 
    close   = {"void", {"GtkAssistant*"}, {"assistant"} }, 
    prepare = {"void", {"GtkAssistant*", "GtkWidget*"}, {"assistant", "page"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    apply   = {ret_type = "void", params = {type = {"GtkAssistant*"}, name ={"assistant"}} }, 
    cancel  = {ret_type = "void", params = {type = {"GtkAssistant*"}, name ={"assistant"}} }, 
    close   = {ret_type = "void", params = {type = {"GtkAssistant*"}, name ={"assistant"}} }, 
    escape  = {ret_type = "void", params = {type = {"GtkAssistant*"}, name ={"assistant"}} }, 
    prepare = {ret_type = "void", params = {type = {"GtkAssistant*", "GtkWidget*"}, name ={"assistant", "page"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["use-header-bar"] = {__type__="gint" ,__default__ = "-1" ,rwflags="rw" },
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    complete          = {__type__="gboolean"             ,__default__ = "FALSE" },
    ["has-padding"]   = {__type__="gboolean"             ,__default__ = "TRUE" },
    ["header-image"]  = {__type__="GdkPixbuf*"            },
    ["page-type"]     = {__type__="GtkAssistantPageType" ,__default__ = "GTK_ASSISTANT_PAGE_CONTENT" },
    ["sidebar-image"] = {__type__="GdkPixbuf*"            },
    title             = {__type__="gchar*"               ,__default__ = "NULL" },
  },
  parent = Gtk324.GtkWindow,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkCheckMenuItem
Gtk324.GtkCheckMenuItem = {
  class = "GtkCheckMenuItem", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_check_menu_item_new()", 
            params = { type = {}, name = {} } },
    new_with_label    = { gencode = "gtk_check_menu_item_new_with_label((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
    new_with_mnemonic = { gencode = "gtk_check_menu_item_new_with_mnemonic((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    draw_indicator = {"void", {"GtkCheckMenuItem*", "cairo_t*"}, {"check_menu_item", "cr"} }, 
    toggled        = {"void", {"GtkCheckMenuItem*"}, {"check_menu_item"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    toggled = {ret_type = "void", params = {type = {"GtkCheckMenuItem*"}, name ={"check_menu_item"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    active            = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_check_menu_item_set_active((GtkCheckMenuItem*)({* id *}), (gboolean)({* property.value *}))"} },
    ["draw-as-radio"] = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_check_menu_item_set_draw_as_radio((GtkCheckMenuItem*)({* id *}), (gboolean)({* property.value *}))"} },
    inconsistent      = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_check_menu_item_set_inconsistent((GtkCheckMenuItem*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk324.GtkMenuItem,
  implement = {Gtk324.GtkActionable, Gtk324.GtkActivatable, Gtk324.GtkBuildable}, 
};

---------------------  GtkCheckMenuItemAccessible
Gtk324.GtkCheckMenuItemAccessible = {
  class = "GtkCheckMenuItemAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkMenuItemAccessible,
};

---------------------  GtkColorButton
Gtk324.GtkColorButton = {
  class = "GtkColorButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_color_button_new()", 
            params = { type = {}, name = {} } },
    new_with_color = { gencode = "gtk_color_button_new_with_color((const GdkColor*)({* this.color.value *}))", 
            params = { type = {"const GdkColor*"}, 
                       name = {"color"} } },
    new_with_rgba  = { gencode = "gtk_color_button_new_with_rgba((const GdkRGBA*)({* this.rgba.value *}))", 
            params = { type = {"const GdkRGBA*"}, 
                       name = {"rgba"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    color_set = {"void", {"GtkColorButton*"}, {"cp"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['color-set'] = {ret_type = "void", params = {type = {"GtkColorButton*"}, name ={"colorbutton"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    alpha           = {__type__="guint"     ,__default__ = "65535"            , __gencode__ = {"gtk_color_button_set_alpha((GtkColorButton*)({* id *}), (guint16)({* property.value *}))"} },
    color           = {__type__="GdkColor*"                                   , __gencode__ = {"gtk_color_button_set_color((GtkColorButton*)({* id *}), (const GdkColor*)({* property.value *}))"} },
    rgba            = {__type__="GdkRGBA*"                                    , __gencode__ = {"gtk_color_button_set_rgba((GtkColorButton*)({* id *}), (const GdkRGBA*)({* property.value *}))"} },
    ["show-editor"] = {__type__="gboolean"  ,__default__ = "FALSE"            ,rwflags="rw" },
    title           = {__type__="gchar*"    ,__default__ = "\"Pick a Color\"" , __gencode__ = {"gtk_color_button_set_title((GtkColorButton*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["use-alpha"]   = {__type__="gboolean"  ,__default__ = "FALSE"            , __gencode__ = {"gtk_color_button_set_use_alpha((GtkColorButton*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk324.GtkButton,
  implement = {Gtk324.GtkActionable, Gtk324.GtkActivatable, Gtk324.GtkBuildable, Gtk324.GtkColorChooser}, 
};

---------------------  GtkComboBoxText
Gtk324.GtkComboBoxText = {
  class = "GtkComboBoxText", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_combo_box_text_new()", 
            params = { type = {}, name = {} } },
    new_with_entry = { gencode = "gtk_combo_box_text_new_with_entry()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkComboBox,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkCellEditable, Gtk324.GtkCellLayout}, 
};

---------------------  GtkDialog
Gtk324.GtkDialog = {
  class = "GtkDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new              = { gencode = "gtk_dialog_new()", 
            params = { type = {}, name = {} } },
    new_with_buttons = { gencode = "gtk_dialog_new_with_buttons((const gchar*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}), (GtkDialogFlags)({* this.flags.value *}), (const gchar*)({* this.first_button_text.value *}), 0)", 
            params = { type = {"const gchar*", "GtkWindow*"}, 
                       name = {"title", "parent"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    close    = {"void", {"GtkDialog*"}, {"dialog"} }, 
    response = {"void", {"GtkDialog*", "gint"}, {"dialog", "response_id"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    close    = {ret_type = "void", params = {type = {"GtkDialog*"}, name ={"dialog"}} }, 
    response = {ret_type = "void", params = {type = {"GtkDialog*", "gint"}, name ={"dialog", "response_id"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["use-header-bar"] = {__type__="gint" ,__default__ = "-1" ,rwflags="rw" },
  },
  parent = Gtk324.GtkWindow,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkFontButton
Gtk324.GtkFontButton = {
  class = "GtkFontButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new           = { gencode = "gtk_font_button_new()", 
            params = { type = {}, name = {} } },
    new_with_font = { gencode = "gtk_font_button_new_with_font((const gchar*)({* this.fontname.value *}))", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    font_set = {"void", {"GtkFontButton*"}, {"gfp"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['font-set'] = {ret_type = "void", params = {type = {"GtkFontButton*"}, name ={"fontbutton"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["font-name"]  = {__type__="gchar*"   ,__default__ = "\"Sans 12\""     , __gencode__ = {"gtk_font_button_set_font_name((GtkFontButton*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["show-size"]  = {__type__="gboolean" ,__default__ = "TRUE"            , __gencode__ = {"gtk_font_button_set_show_size((GtkFontButton*)({* id *}), (gboolean)({* property.value *}))"} },
    ["show-style"] = {__type__="gboolean" ,__default__ = "TRUE"            , __gencode__ = {"gtk_font_button_set_show_style((GtkFontButton*)({* id *}), (gboolean)({* property.value *}))"} },
    title          = {__type__="gchar*"   ,__default__ = "\"Pick a Font\"" , __gencode__ = {"gtk_font_button_set_title((GtkFontButton*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["use-font"]   = {__type__="gboolean" ,__default__ = "FALSE"           , __gencode__ = {"gtk_font_button_set_use_font((GtkFontButton*)({* id *}), (gboolean)({* property.value *}))"} },
    ["use-size"]   = {__type__="gboolean" ,__default__ = "FALSE"           , __gencode__ = {"gtk_font_button_set_use_size((GtkFontButton*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk324.GtkButton,
  implement = {Gtk324.GtkActionable, Gtk324.GtkActivatable, Gtk324.GtkBuildable, Gtk324.GtkFontChooser}, 
};

---------------------  GtkGesturePan
Gtk324.GtkGesturePan = {
  class = "GtkGesturePan", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_gesture_pan_new((GtkWidget*)({* this.widget.value *}), (GtkOrientation)({* this.orientation.value *}))", 
            params = { type = {"GtkWidget*", "GtkOrientation"}, 
                       name = {"widget", "orientation"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    pan = {ret_type = "void", params = {type = {"GtkGesturePan*", "GtkPanDirection", "gdouble"}, name ={"gesturepan", "direction", "offset"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    orientation = {__type__="GtkOrientation" ,__default__ = "GTK_ORIENTATION_HORIZONTAL" , __gencode__ = {"gtk_gesture_pan_set_orientation((GtkGesturePan*)({* id *}), (GtkOrientation)({* property.value *}))"} },
  },
  parent = Gtk324.GtkGestureDrag,
};

---------------------  GtkHButtonBox
Gtk324.GtkHButtonBox = {
  class = "GtkHButtonBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_hbutton_box_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkButtonBox,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkImageMenuItem
Gtk324.GtkImageMenuItem = {
  class = "GtkImageMenuItem", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_image_menu_item_new()", 
            params = { type = {}, name = {} } },
    new_from_stock    = { gencode = "gtk_image_menu_item_new_from_stock((const gchar*)({* this.stock_id.value *}), (GtkAccelGroup*)({* this['accel-group'].value *}))", 
            params = { type = {"GtkAccelGroup*"}, 
                       name = {"accel-group"} } },
    new_with_label    = { gencode = "gtk_image_menu_item_new_with_label((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
    new_with_mnemonic = { gencode = "gtk_image_menu_item_new_with_mnemonic((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["accel-group"]       = {__type__="GtkAccelGroup*"                        , __gencode__ = {"gtk_image_menu_item_set_accel_group((GtkImageMenuItem*)({* id *}), (GtkAccelGroup*)({* property.value *}))"} },
    ["always-show-image"] = {__type__="gboolean"       ,__default__ = "FALSE" , __gencode__ = {"gtk_image_menu_item_set_always_show_image((GtkImageMenuItem*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
    image                 = {__type__="GtkWidget*"                            , __gencode__ = {"gtk_image_menu_item_set_image((GtkImageMenuItem*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["use-stock"]         = {__type__="gboolean"       ,__default__ = "FALSE" , __gencode__ = {"gtk_image_menu_item_set_use_stock((GtkImageMenuItem*)({* id *}), (gboolean)({* property.value *}))"},__construct__= 1 },
  },
  parent = Gtk324.GtkMenuItem,
  implement = {Gtk324.GtkActionable, Gtk324.GtkActivatable, Gtk324.GtkBuildable}, 
};

---------------------  GtkLinkButton
Gtk324.GtkLinkButton = {
  class = "GtkLinkButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_link_button_new((const gchar*)({* this.uri.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"uri"} } },
    new_with_label = { gencode = "gtk_link_button_new_with_label((const gchar*)({* this.uri.value *}), (const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*", "const gchar*"}, 
                       name = {"uri", "label"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate_link = {"gboolean", {"GtkLinkButton*"}, {"button"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['activate-link'] = {ret_type = "gboolean", params = {type = {"GtkLinkButton*"}, name ={"linkbutton"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    uri     = {__type__="gchar*"   ,__default__ = "NULL"  , __gencode__ = {"gtk_link_button_set_uri((GtkLinkButton*)({* id *}), (const gchar*)({* property.value *}))"} },
    visited = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_link_button_set_visited((GtkLinkButton*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk324.GtkButton,
  implement = {Gtk324.GtkActionable, Gtk324.GtkActivatable, Gtk324.GtkBuildable}, 
};

---------------------  GtkLinkButtonAccessible
Gtk324.GtkLinkButtonAccessible = {
  class = "GtkLinkButtonAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkButtonAccessible,
};

---------------------  GtkLockButton
Gtk324.GtkLockButton = {
  class = "GtkLockButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_lock_button_new((GPermission*)({* this.permission.value *}))", 
            params = { type = {"GPermission*"}, 
                       name = {"permission"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    permission                 = {__type__="GPermission*"                                                                                         , __gencode__ = {"gtk_lock_button_set_permission((GtkLockButton*)({* id *}), (GPermission*)({* property.value *}))"} },
    ["text-lock"]              = {__type__="gchar*"       ,__default__ = "\"Lock\""                                                               ,rwflags="rw",__construct__= 1 },
    ["text-unlock"]            = {__type__="gchar*"       ,__default__ = "\"Unlock\""                                                             ,rwflags="rw",__construct__= 1 },
    ["tooltip-lock"]           = {__type__="gchar*"       ,__default__ = "\"Dialog is unlocked.\nClick to prevent further changes\""              ,rwflags="rw",__construct__= 1 },
    ["tooltip-not-authorized"] = {__type__="gchar*"       ,__default__ = "\"System policy prevents changes.\nContact your system administrator\"" ,rwflags="rw",__construct__= 1 },
    ["tooltip-unlock"]         = {__type__="gchar*"       ,__default__ = "\"Dialog is locked.\nClick to make changes\""                           ,rwflags="rw",__construct__= 1 },
  },
  parent = Gtk324.GtkButton,
  implement = {Gtk324.GtkActionable, Gtk324.GtkActivatable, Gtk324.GtkBuildable}, 
};

---------------------  GtkLockButtonAccessible
Gtk324.GtkLockButtonAccessible = {
  class = "GtkLockButtonAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkButtonAccessible,
};

---------------------  GtkMenuAccessible
Gtk324.GtkMenuAccessible = {
  class = "GtkMenuAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkMenuShellAccessible,
};

---------------------  GtkModelButton
Gtk324.GtkModelButton = {
  class = "GtkModelButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_model_button_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    active         = {__type__="gboolean"      ,__default__ = "FALSE"                  ,rwflags="rw" },
    centered       = {__type__="gboolean"      ,__default__ = "FALSE"                  ,rwflags="rw" },
    icon           = {__type__="GIcon*"                                                ,rwflags="rw" },
    iconic         = {__type__="gboolean"      ,__default__ = "FALSE"                  ,rwflags="rw" },
    inverted       = {__type__="gboolean"      ,__default__ = "FALSE"                  ,rwflags="rw" },
    ["menu-name"]  = {__type__="gchar*"        ,__default__ = "NULL"                   ,rwflags="rw" },
    role           = {__type__="GtkButtonRole" ,__default__ = "GTK_BUTTON_ROLE_NORMAL" ,rwflags="rw" },
    text           = {__type__="gchar*"        ,__default__ = "\"\""                   ,rwflags="rw" },
    ["use-markup"] = {__type__="gboolean"      ,__default__ = "FALSE"                  ,rwflags="rw" },
  },
  parent = Gtk324.GtkButton,
  implement = {Gtk324.GtkActionable, Gtk324.GtkActivatable, Gtk324.GtkBuildable}, 
};

---------------------  GtkOffscreenWindow
Gtk324.GtkOffscreenWindow = {
  class = "GtkOffscreenWindow", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_offscreen_window_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkWindow,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkPlacesSidebar
Gtk324.GtkPlacesSidebar = {
  class = "GtkPlacesSidebar", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_places_sidebar_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['drag-action-ask']                 = {ret_type = "gint", params = {type = {"GtkPlacesSidebar*", "gint"}, name ={"placessidebar", "actions"}} }, 
    ['drag-action-requested']           = {ret_type = "gint", params = {type = {"GtkPlacesSidebar*", "GdkDragContext*", "GFile*", "gpointer"}, name ={"placessidebar", "context", "dest_file", "source_file_list"}} }, 
    ['drag-perform-drop']               = {ret_type = "void", params = {type = {"GtkPlacesSidebar*", "GFile*", "gpointer", "gint"}, name ={"placessidebar", "dest_file", "source_file_list", "action"}} }, 
    mount                               = {ret_type = "void", params = {type = {"GtkPlacesSidebar*", "GMountOperation*"}, name ={"placessidebar", "mount_operation"}} }, 
    ['open-location']                   = {ret_type = "void", params = {type = {"GtkPlacesSidebar*", "GFile*", "GtkPlacesOpenFlags*"}, name ={"placessidebar", "location", "open_flags"}} }, 
    ['populate-popup']                  = {ret_type = "void", params = {type = {"GtkPlacesSidebar*", "GtkWidget*", "GFile*", "GVolume*"}, name ={"placessidebar", "container", "selected_item", "selected_volume"}} }, 
    ['show-connect-to-server']          = {ret_type = "void", params = {type = {"GtkPlacesSidebar*"}, name ={"placessidebar"}} }, 
    ['show-enter-location']             = {ret_type = "void", params = {type = {"GtkPlacesSidebar*"}, name ={"placessidebar"}} }, 
    ['show-error-message']              = {ret_type = "void", params = {type = {"GtkPlacesSidebar*", "gchar*", "gchar*"}, name ={"placessidebar", "primary", "secondary"}} }, 
    ['show-other-locations']            = {ret_type = "void", params = {type = {"GtkPlacesSidebar*"}, name ={"placessidebar"}} }, 
    ['show-other-locations-with-flags'] = {ret_type = "void", params = {type = {"GtkPlacesSidebar*", "GtkPlacesOpenFlags*"}, name ={"placessidebar", "open_flags"}} }, 
    ['show-starred-location']           = {ret_type = "void", params = {type = {"GtkPlacesSidebar*", "GtkPlacesOpenFlags*"}, name ={"placessidebar", "open_flags"}} }, 
    unmount                             = {ret_type = "void", params = {type = {"GtkPlacesSidebar*", "GMountOperation*"}, name ={"placessidebar", "mount_operation"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["local-only"]             = {__type__="gboolean"            ,__default__ = "FALSE"                  , __gencode__ = {"gtk_places_sidebar_set_local_only((GtkPlacesSidebar*)({* id *}), (gboolean)({* property.value *}))"} },
    location                   = {__type__="GFile*"                                                      , __gencode__ = {"gtk_places_sidebar_set_location((GtkPlacesSidebar*)({* id *}), (GFile*)({* property.value *}))"} },
    ["open-flags"]             = {__type__="GtkPlacesOpenFlags*" ,__default__ = "GTK_PLACES_OPEN_NORMAL" , __gencode__ = {"gtk_places_sidebar_set_open_flags((GtkPlacesSidebar*)({* id *}), (GtkPlacesOpenFlags)({* property.value *}))"} },
    ["populate-all"]           = {__type__="gboolean"            ,__default__ = "FALSE"                  ,rwflags="rw" },
    ["show-connect-to-server"] = {__type__="gboolean"            ,__default__ = "FALSE"                  , __gencode__ = {"gtk_places_sidebar_set_show_connect_to_server((GtkPlacesSidebar*)({* id *}), (gboolean)({* property.value *}))"} },
    ["show-desktop"]           = {__type__="gboolean"            ,__default__ = "TRUE"                   , __gencode__ = {"gtk_places_sidebar_set_show_desktop((GtkPlacesSidebar*)({* id *}), (gboolean)({* property.value *}))"} },
    ["show-enter-location"]    = {__type__="gboolean"            ,__default__ = "FALSE"                  , __gencode__ = {"gtk_places_sidebar_set_show_enter_location((GtkPlacesSidebar*)({* id *}), (gboolean)({* property.value *}))"} },
    ["show-other-locations"]   = {__type__="gboolean"            ,__default__ = "FALSE"                  , __gencode__ = {"gtk_places_sidebar_set_show_other_locations((GtkPlacesSidebar*)({* id *}), (gboolean)({* property.value *}))"} },
    ["show-recent"]            = {__type__="gboolean"            ,__default__ = "TRUE"                   , __gencode__ = {"gtk_places_sidebar_set_show_recent((GtkPlacesSidebar*)({* id *}), (gboolean)({* property.value *}))"} },
    ["show-starred-location"]  = {__type__="gboolean"            ,__default__ = "FALSE"                  , __gencode__ = {"gtk_places_sidebar_set_show_starred_location((GtkPlacesSidebar*)({* id *}), (gboolean)({* property.value *}))"} },
    ["show-trash"]             = {__type__="gboolean"            ,__default__ = "TRUE"                   , __gencode__ = {"gtk_places_sidebar_set_show_trash((GtkPlacesSidebar*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk324.GtkScrolledWindow,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkPlug
Gtk324.GtkPlug = {
  class = "GtkPlug", 
  constructor = { 
    -- 名称[- ==> _], 
    new             = { gencode = "gtk_plug_new((Window)({* this.socket_id.value *}))", 
            params = { type = {}, name = {} } },
    new_for_display = { gencode = "gtk_plug_new_for_display((GdkDisplay*)({* this.display.value *}), (Window)({* this.socket_id.value *}))", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    embedded = {"void", {"GtkPlug*"}, {"plug"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    embedded = {ret_type = "void", params = {type = {"GtkPlug*"}, name ={"plug"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    embedded          = {__type__="gboolean"   ,__default__ = "FALSE"  },
    ["socket-window"] = {__type__="GdkWindow*"                         },
  },
  parent = Gtk324.GtkWindow,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkPlugAccessible
Gtk324.GtkPlugAccessible = {
  class = "GtkPlugAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkWindowAccessible,
};

---------------------  GtkPopoverMenu
Gtk324.GtkPopoverMenu = {
  class = "GtkPopoverMenu", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_popover_menu_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["visible-submenu"] = {__type__="gchar*" ,__default__ = "NULL" ,rwflags="rw" },
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值
    position = {__type__="gint"   ,__default__ = "0" },
    submenu  = {__type__="gchar*" ,__default__ = "NULL" },
  },
  parent = Gtk324.GtkPopover,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkRecentChooserMenu
Gtk324.GtkRecentChooserMenu = {
  class = "GtkRecentChooserMenu", 
  constructor = { 
    -- 名称[- ==> _], 
    new             = { gencode = "gtk_recent_chooser_menu_new()", 
            params = { type = {}, name = {} } },
    new_for_manager = { gencode = "gtk_recent_chooser_menu_new_for_manager((GtkRecentManager*)({* this.manager.value *}))", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["show-numbers"] = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_recent_chooser_menu_set_show_numbers((GtkRecentChooserMenu*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk324.GtkMenu,
  implement = {Gtk324.GtkActivatable, Gtk324.GtkBuildable, Gtk324.GtkRecentChooser}, 
};

---------------------  GtkScaleButton
Gtk324.GtkScaleButton = {
  class = "GtkScaleButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_scale_button_new((GtkIconSize)({* this.size.value *}), (gdouble)({* this.min.value *}), (gdouble)({* this.max.value *}), (gdouble)({* this.step.value *}), (const gchar**)({* this.icons.value *}))", 
            params = { type = {"GtkIconSize", "const gchar**"}, 
                       name = {"size", "icons"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    value_changed = {"void", {"GtkScaleButton*", "gdouble"}, {"button", "value"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    popdown           = {ret_type = "void", params = {type = {"GtkScaleButton*"}, name ={"scalebutton"}} }, 
    popup             = {ret_type = "void", params = {type = {"GtkScaleButton*"}, name ={"scalebutton"}} }, 
    ['value-changed'] = {ret_type = "void", params = {type = {"GtkScaleButton*", "gdouble"}, name ={"scalebutton", "value"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    adjustment = {__type__="GtkAdjustment*"                                              , __gencode__ = {"gtk_scale_button_set_adjustment((GtkScaleButton*)({* id *}), (GtkAdjustment*)({* property.value *}))"} },
    icons      = {__type__="GStrv"                                                       , __gencode__ = {"gtk_scale_button_set_icons((GtkScaleButton*)({* id *}), (const gchar**)({* property.value *}))"} },
    size       = {__type__="GtkIconSize"    ,__default__ = "GTK_ICON_SIZE_SMALL_TOOLBAR" ,rwflags="rw" },
    value      = {__type__="gdouble"        ,__default__ = "0"                           , __gencode__ = {"gtk_scale_button_set_value((GtkScaleButton*)({* id *}), (gdouble)({* property.value *}))"} },
  },
  parent = Gtk324.GtkButton,
  implement = {Gtk324.GtkActionable, Gtk324.GtkActivatable, Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkScaleButtonAccessible
Gtk324.GtkScaleButtonAccessible = {
  class = "GtkScaleButtonAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkButtonAccessible,
};

---------------------  GtkSeparatorMenuItem
Gtk324.GtkSeparatorMenuItem = {
  class = "GtkSeparatorMenuItem", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_separator_menu_item_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkMenuItem,
  implement = {Gtk324.GtkActionable, Gtk324.GtkActivatable, Gtk324.GtkBuildable}, 
};

---------------------  GtkSeparatorToolItem
Gtk324.GtkSeparatorToolItem = {
  class = "GtkSeparatorToolItem", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_separator_tool_item_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    draw = {__type__="gboolean" ,__default__ = "TRUE" , __gencode__ = {"gtk_separator_tool_item_set_draw((GtkSeparatorToolItem*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk324.GtkToolItem,
  implement = {Gtk324.GtkActivatable, Gtk324.GtkBuildable}, 
};

---------------------  GtkShortcutsWindow
Gtk324.GtkShortcutsWindow = {
  class = "GtkShortcutsWindow", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    close  = {"void", {"GtkShortcutsWindow*"}, {"self"} }, 
    search = {"void", {"GtkShortcutsWindow*"}, {"self"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    close  = {ret_type = "void", params = {type = {"GtkShortcutsWindow*"}, name ={"self"}} }, 
    search = {ret_type = "void", params = {type = {"GtkShortcutsWindow*"}, name ={"self"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["section-name"] = {__type__="gchar*" ,__default__ = "\"internal-search\"" ,rwflags="rw" },
    ["view-name"]    = {__type__="gchar*" ,__default__ = "NULL"                ,rwflags="rw" },
  },
  parent = Gtk324.GtkWindow,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkTearoffMenuItem
Gtk324.GtkTearoffMenuItem = {
  class = "GtkTearoffMenuItem", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_tearoff_menu_item_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkMenuItem,
  implement = {Gtk324.GtkActionable, Gtk324.GtkActivatable, Gtk324.GtkBuildable}, 
};

---------------------  GtkToggleButton
Gtk324.GtkToggleButton = {
  class = "GtkToggleButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_toggle_button_new()", 
            params = { type = {}, name = {} } },
    new_with_label    = { gencode = "gtk_toggle_button_new_with_label((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
    new_with_mnemonic = { gencode = "gtk_toggle_button_new_with_mnemonic((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    toggled = {"void", {"GtkToggleButton*"}, {"toggle_button"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    toggled = {ret_type = "void", params = {type = {"GtkToggleButton*"}, name ={"toggle_button"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    active             = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_toggle_button_set_active((GtkToggleButton*)({* id *}), (gboolean)({* property.value *}))"} },
    ["draw-indicator"] = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
    inconsistent       = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_toggle_button_set_inconsistent((GtkToggleButton*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk324.GtkButton,
  implement = {Gtk324.GtkActionable, Gtk324.GtkActivatable, Gtk324.GtkBuildable}, 
};

---------------------  GtkToggleButtonAccessible
Gtk324.GtkToggleButtonAccessible = {
  class = "GtkToggleButtonAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkButtonAccessible,
};

---------------------  GtkToolButton
Gtk324.GtkToolButton = {
  class = "GtkToolButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_tool_button_new((GtkWidget*)({* this['icon-widget']value *}), (const gchar*)({* this.label.value *}))", 
            params = { type = {"GtkWidget*", "const gchar*"}, 
                       name = {"icon-widget", "label"} } },
    new_from_stock = { gencode = "gtk_tool_button_new_from_stock((const gchar*)({* this['stock-id']value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"stock-id"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    clicked = {"void", {"GtkToolButton*"}, {"tool_item"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    clicked = {ret_type = "void", params = {type = {"GtkToolButton*"}, name ={"tool_item"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["icon-name"]     = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_tool_button_set_icon_name((GtkToolButton*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["icon-widget"]   = {__type__="GtkWidget*"                        , __gencode__ = {"gtk_tool_button_set_icon_widget((GtkToolButton*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    label             = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_tool_button_set_label((GtkToolButton*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["label-widget"]  = {__type__="GtkWidget*"                        , __gencode__ = {"gtk_tool_button_set_label_widget((GtkToolButton*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["stock-id"]      = {__type__="gchar*"     ,__default__ = "NULL"  , __gencode__ = {"gtk_tool_button_set_stock_id((GtkToolButton*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["use-underline"] = {__type__="gboolean"   ,__default__ = "FALSE" , __gencode__ = {"gtk_tool_button_set_use_underline((GtkToolButton*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk324.GtkToolItem,
  implement = {Gtk324.GtkActionable, Gtk324.GtkActivatable, Gtk324.GtkBuildable}, 
};

---------------------  GtkVButtonBox
Gtk324.GtkVButtonBox = {
  class = "GtkVButtonBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_vbutton_box_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkButtonBox,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkAboutDialog
Gtk324.GtkAboutDialog = {
  class = "GtkAboutDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_about_dialog_new()", 
            params = { type = {}, name = {} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    activate_link = {"gboolean", {"GtkAboutDialog*", "const gchar*"}, {"dialog", "uri"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['activate-link'] = {ret_type = "gboolean", params = {type = {"GtkAboutDialog*", "gchar*"}, name ={"aboutdialog", "uri"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    artists                = {__type__="GStrv"                                           , __gencode__ = {"gtk_about_dialog_set_artists((GtkAboutDialog*)({* id *}), (const gchar**)({* property.value *}))"} },
    authors                = {__type__="GStrv"                                           , __gencode__ = {"gtk_about_dialog_set_authors((GtkAboutDialog*)({* id *}), (const gchar**)({* property.value *}))"} },
    comments               = {__type__="gchar*"     ,__default__ = "NULL"                , __gencode__ = {"gtk_about_dialog_set_comments((GtkAboutDialog*)({* id *}), (const gchar*)({* property.value *}))"} },
    copyright              = {__type__="gchar*"     ,__default__ = "NULL"                , __gencode__ = {"gtk_about_dialog_set_copyright((GtkAboutDialog*)({* id *}), (const gchar*)({* property.value *}))"} },
    documenters            = {__type__="GStrv"                                           , __gencode__ = {"gtk_about_dialog_set_documenters((GtkAboutDialog*)({* id *}), (const gchar**)({* property.value *}))"} },
    license                = {__type__="gchar*"     ,__default__ = "NULL"                , __gencode__ = {"gtk_about_dialog_set_license((GtkAboutDialog*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["license-type"]       = {__type__="GtkLicense" ,__default__ = "GTK_LICENSE_UNKNOWN" , __gencode__ = {"gtk_about_dialog_set_license_type((GtkAboutDialog*)({* id *}), (GtkLicense)({* property.value *}))"} },
    logo                   = {__type__="GdkPixbuf*"                                      , __gencode__ = {"gtk_about_dialog_set_logo((GtkAboutDialog*)({* id *}), (GdkPixbuf*)({* property.value *}))"} },
    ["logo-icon-name"]     = {__type__="gchar*"     ,__default__ = "\"image-missing\""   , __gencode__ = {"gtk_about_dialog_set_logo_icon_name((GtkAboutDialog*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["program-name"]       = {__type__="gchar*"     ,__default__ = "NULL"                , __gencode__ = {"gtk_about_dialog_set_program_name((GtkAboutDialog*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["translator-credits"] = {__type__="gchar*"     ,__default__ = "NULL"                , __gencode__ = {"gtk_about_dialog_set_translator_credits((GtkAboutDialog*)({* id *}), (const gchar*)({* property.value *}))"} },
    version                = {__type__="gchar*"     ,__default__ = "NULL"                , __gencode__ = {"gtk_about_dialog_set_version((GtkAboutDialog*)({* id *}), (const gchar*)({* property.value *}))"} },
    website                = {__type__="gchar*"     ,__default__ = "NULL"                , __gencode__ = {"gtk_about_dialog_set_website((GtkAboutDialog*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["website-label"]      = {__type__="gchar*"     ,__default__ = "NULL"                , __gencode__ = {"gtk_about_dialog_set_website_label((GtkAboutDialog*)({* id *}), (const gchar*)({* property.value *}))"} },
    ["wrap-license"]       = {__type__="gboolean"   ,__default__ = "FALSE"               , __gencode__ = {"gtk_about_dialog_set_wrap_license((GtkAboutDialog*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk324.GtkDialog,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkAppChooserDialog
Gtk324.GtkAppChooserDialog = {
  class = "GtkAppChooserDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new                  = { gencode = "gtk_app_chooser_dialog_new((GtkWindow*)({* this.parent.value *}), (GtkDialogFlags)({* this.flags.value *}), (GFile*)({* this.file.value *}))", 
            params = { type = {"GtkWindow*"}, 
                       name = {"parent"} } },
    new_for_content_type = { gencode = "gtk_app_chooser_dialog_new_for_content_type((GtkWindow*)({* this.parent.value *}), (GtkDialogFlags)({* this.flags.value *}), (const gchar*)({* this['content-type'].value *}))", 
            params = { type = {"GtkWindow*", "const gchar*"}, 
                       name = {"parent", "content-type"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    gfile   = {__type__="GFile*"                       ,rwflags="rw" },
    heading = {__type__="gchar*" ,__default__ = "NULL" , __gencode__ = {"gtk_app_chooser_dialog_set_heading((GtkAppChooserDialog*)({* id *}), (const gchar*)({* property.value *}))"} },
  },
  parent = Gtk324.GtkDialog,
  implement = {Gtk324.GtkAppChooser, Gtk324.GtkBuildable}, 
};

---------------------  GtkCheckButton
Gtk324.GtkCheckButton = {
  class = "GtkCheckButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new               = { gencode = "gtk_check_button_new()", 
            params = { type = {}, name = {} } },
    new_with_label    = { gencode = "gtk_check_button_new_with_label((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
    new_with_mnemonic = { gencode = "gtk_check_button_new_with_mnemonic((const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    draw_indicator = {"void", {"GtkCheckButton*", "cairo_t*"}, {"check_button", "cr"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkToggleButton,
  implement = {Gtk324.GtkActionable, Gtk324.GtkActivatable, Gtk324.GtkBuildable}, 
};

---------------------  GtkColorChooserDialog
Gtk324.GtkColorChooserDialog = {
  class = "GtkColorChooserDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_color_chooser_dialog_new((const gchar*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}))", 
            params = { type = {"const gchar*", "GtkWindow*"}, 
                       name = {"title", "parent"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["show-editor"] = {__type__="gboolean" ,__default__ = "FALSE" ,rwflags="rw" },
  },
  parent = Gtk324.GtkDialog,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkColorChooser}, 
};

---------------------  GtkColorSelectionDialog
Gtk324.GtkColorSelectionDialog = {
  class = "GtkColorSelectionDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_color_selection_dialog_new((const gchar*)({* this.title.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"title"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["cancel-button"]   = {__type__="GtkWidget*"  },
    ["color-selection"] = {__type__="GtkWidget*"  },
    ["help-button"]     = {__type__="GtkWidget*"  },
    ["ok-button"]       = {__type__="GtkWidget*"  },
  },
  parent = Gtk324.GtkDialog,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkFileChooserDialog
Gtk324.GtkFileChooserDialog = {
  class = "GtkFileChooserDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_file_chooser_dialog_new((const gchar*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}), (GtkFileChooserAction)({* this.action.value *}), (const gchar*)({* this.first_button_text.value *}), 0)", 
            params = { type = {"const gchar*", "GtkWindow*", "GtkFileChooserAction"}, 
                       name = {"title", "parent", "action"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkDialog,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkFileChooser}, 
};

---------------------  GtkFontChooserDialog
Gtk324.GtkFontChooserDialog = {
  class = "GtkFontChooserDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_font_chooser_dialog_new((const gchar*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}))", 
            params = { type = {"const gchar*", "GtkWindow*"}, 
                       name = {"title", "parent"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkDialog,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkFontChooser}, 
};

---------------------  GtkFontSelectionDialog
Gtk324.GtkFontSelectionDialog = {
  class = "GtkFontSelectionDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_font_selection_dialog_new((const gchar*)({* this.title.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"title"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkDialog,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkMenuButton
Gtk324.GtkMenuButton = {
  class = "GtkMenuButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_menu_button_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["align-widget"] = {__type__="GtkContainer*"                                 , __gencode__ = {"gtk_menu_button_set_align_widget((GtkMenuButton*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    direction        = {__type__="GtkArrowType"  ,__default__ = "GTK_ARROW_DOWN" , __gencode__ = {"gtk_menu_button_set_direction((GtkMenuButton*)({* id *}), (GtkArrowType)({* property.value *}))"} },
    ["menu-model"]   = {__type__="GMenuModel*"                                   , __gencode__ = {"gtk_menu_button_set_menu_model((GtkMenuButton*)({* id *}), (GMenuModel*)({* property.value *}))"} },
    popover          = {__type__="GtkPopover*"                                   , __gencode__ = {"gtk_menu_button_set_popover((GtkMenuButton*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    popup            = {__type__="GtkMenu*"                                      , __gencode__ = {"gtk_menu_button_set_popup((GtkMenuButton*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["use-popover"]  = {__type__="gboolean"      ,__default__ = "TRUE"           , __gencode__ = {"gtk_menu_button_set_use_popover((GtkMenuButton*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk324.GtkToggleButton,
  implement = {Gtk324.GtkActionable, Gtk324.GtkActivatable, Gtk324.GtkBuildable}, 
};

---------------------  GtkMenuButtonAccessible
Gtk324.GtkMenuButtonAccessible = {
  class = "GtkMenuButtonAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkToggleButtonAccessible,
};

---------------------  GtkMenuToolButton
Gtk324.GtkMenuToolButton = {
  class = "GtkMenuToolButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_menu_tool_button_new((GtkWidget*)({* this['icon-widget']value *}), (const gchar*)({* this.label.value *}))", 
            params = { type = {"GtkWidget*", "const gchar*"}, 
                       name = {"icon-widget", "label"} } },
    new_from_stock = { gencode = "gtk_menu_tool_button_new_from_stock((const gchar*)({* this['stock-id']value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"stock-id"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    show_menu = {"void", {"GtkMenuToolButton*"}, {"button"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['show-menu'] = {ret_type = "void", params = {type = {"GtkMenuToolButton*"}, name ={"menutoolbutton"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    menu = {__type__="GtkMenu*" , __gencode__ = {"gtk_menu_tool_button_set_menu((GtkMenuToolButton*)({* id *}), (GtkWidget*)({* property.value *}))"} },
  },
  parent = Gtk324.GtkToolButton,
  implement = {Gtk324.GtkActionable, Gtk324.GtkActivatable, Gtk324.GtkBuildable}, 
};

---------------------  GtkMessageDialog
Gtk324.GtkMessageDialog = {
  class = "GtkMessageDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new             = { gencode = "gtk_message_dialog_new((GtkWindow*)({* this.parent.value *}), (GtkDialogFlags)({* this.flags.value *}), (GtkMessageType)({* this.type.value *}), (GtkButtonsType)({* this.buttons.value *}), (const gchar*)({* this.message_format.value *}), 0)", 
            params = { type = {"GtkWindow*", "GtkMessageType", "GtkButtonsType"}, 
                       name = {"parent", "type", "buttons"} } },
    new_with_markup = { gencode = "gtk_message_dialog_new_with_markup((GtkWindow*)({* this.parent.value *}), (GtkDialogFlags)({* this.flags.value *}), (GtkMessageType)({* this.type.value *}), (GtkButtonsType)({* this.buttons.value *}), (const gchar*)({* this.message_format.value *}), 0)", 
            params = { type = {"GtkWindow*", "GtkMessageType", "GtkButtonsType"}, 
                       name = {"parent", "type", "buttons"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    buttons                  = {__type__="GtkButtonsType" ,__default__ = "GTK_BUTTONS_NONE" ,rwflags="w" },
    image                    = {__type__="GtkWidget*"                                       , __gencode__ = {"gtk_message_dialog_set_image((GtkMessageDialog*)({* id *}), (GtkWidget*)({* property.value *}))"} },
    ["message-area"]         = {__type__="GtkWidget*"                                        },
    ["message-type"]         = {__type__="GtkMessageType" ,__default__ = "GTK_MESSAGE_INFO" ,rwflags="rw",__construct__= 1 },
    ["secondary-text"]       = {__type__="gchar*"         ,__default__ = "NULL"             ,rwflags="rw" },
    ["secondary-use-markup"] = {__type__="gboolean"       ,__default__ = "FALSE"            ,rwflags="rw" },
    text                     = {__type__="gchar*"         ,__default__ = "\"\""             ,rwflags="rw" },
    ["use-markup"]           = {__type__="gboolean"       ,__default__ = "FALSE"            ,rwflags="rw" },
  },
  parent = Gtk324.GtkDialog,
  implement = {Gtk324.GtkBuildable}, 
};

---------------------  GtkRadioButtonAccessible
Gtk324.GtkRadioButtonAccessible = {
  class = "GtkRadioButtonAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkToggleButtonAccessible,
};

---------------------  GtkRadioMenuItem
Gtk324.GtkRadioMenuItem = {
  class = "GtkRadioMenuItem", 
  constructor = { 
    -- 名称[- ==> _], 
    new                           = { gencode = "gtk_radio_menu_item_new((GSList*)({* this.group.value *}))", 
            params = { type = {"GSList*"}, 
                       name = {"group"} } },
    new_from_widget               = { gencode = "gtk_radio_menu_item_new_from_widget((GtkRadioMenuItem*)({* this.group.value *}))", 
            params = { type = {"GtkRadioMenuItem*"}, 
                       name = {"group"} } },
    new_with_label                = { gencode = "gtk_radio_menu_item_new_with_label((GSList*)({* this.group.value *}), (const gchar*)({* this.label.value *}))", 
            params = { type = {"GSList*", "const gchar*"}, 
                       name = {"group", "label"} } },
    new_with_label_from_widget    = { gencode = "gtk_radio_menu_item_new_with_label_from_widget((GtkRadioMenuItem*)({* this.group.value *}), (const gchar*)({* this.label.value *}))", 
            params = { type = {"GtkRadioMenuItem*", "const gchar*"}, 
                       name = {"group", "label"} } },
    new_with_mnemonic             = { gencode = "gtk_radio_menu_item_new_with_mnemonic((GSList*)({* this.group.value *}), (const gchar*)({* this.label.value *}))", 
            params = { type = {"GSList*", "const gchar*"}, 
                       name = {"group", "label"} } },
    new_with_mnemonic_from_widget = { gencode = "gtk_radio_menu_item_new_with_mnemonic_from_widget((GtkRadioMenuItem*)({* this.group.value *}), (const gchar*)({* this.label.value *}))", 
            params = { type = {"GtkRadioMenuItem*", "const gchar*"}, 
                       name = {"group", "label"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    group_changed = {"void", {"GtkRadioMenuItem*"}, {"radio_menu_item"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['group-changed'] = {ret_type = "void", params = {type = {"GtkRadioMenuItem*"}, name ={"radiomenuitem"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    group = {__type__="GtkRadioMenuItem*" , __gencode__ = {"gtk_radio_menu_item_set_group((GtkRadioMenuItem*)({* id *}), (GSList*)({* property.value *}))"} },
  },
  parent = Gtk324.GtkCheckMenuItem,
  implement = {Gtk324.GtkActionable, Gtk324.GtkActivatable, Gtk324.GtkBuildable}, 
};

---------------------  GtkRadioMenuItemAccessible
Gtk324.GtkRadioMenuItemAccessible = {
  class = "GtkRadioMenuItemAccessible", 
  constructor = { 
    -- 名称[- ==> _], 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkCheckMenuItemAccessible,
};

---------------------  GtkRecentChooserDialog
Gtk324.GtkRecentChooserDialog = {
  class = "GtkRecentChooserDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new             = { gencode = "gtk_recent_chooser_dialog_new((const gchar*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}), (const gchar*)({* this.first_button_text.value *}), 0)", 
            params = { type = {"const gchar*", "GtkWindow*"}, 
                       name = {"title", "parent"} } },
    new_for_manager = { gencode = "gtk_recent_chooser_dialog_new_for_manager((const gchar*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}), (GtkRecentManager*)({* this.manager.value *}), (const gchar*)({* this.first_button_text.value *}), 0)", 
            params = { type = {"const gchar*", "GtkWindow*"}, 
                       name = {"title", "parent"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkDialog,
  implement = {Gtk324.GtkBuildable, Gtk324.GtkRecentChooser}, 
};

---------------------  GtkToggleToolButton
Gtk324.GtkToggleToolButton = {
  class = "GtkToggleToolButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new            = { gencode = "gtk_toggle_tool_button_new()", 
            params = { type = {}, name = {} } },
    new_from_stock = { gencode = "gtk_toggle_tool_button_new_from_stock((const gchar*)({* this['stock-id']value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"stock-id"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    toggled = {"void", {"GtkToggleToolButton*"}, {"button"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    toggled = {ret_type = "void", params = {type = {"GtkToggleToolButton*"}, name ={"button"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    active = {__type__="gboolean" ,__default__ = "FALSE" , __gencode__ = {"gtk_toggle_tool_button_set_active((GtkToggleToolButton*)({* id *}), (gboolean)({* property.value *}))"} },
  },
  parent = Gtk324.GtkToolButton,
  implement = {Gtk324.GtkActionable, Gtk324.GtkActivatable, Gtk324.GtkBuildable}, 
};

---------------------  GtkVolumeButton
Gtk324.GtkVolumeButton = {
  class = "GtkVolumeButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_volume_button_new()", 
            params = { type = {}, name = {} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    ["use-symbolic"] = {__type__="gboolean" ,__default__ = "TRUE" ,rwflags="rw",__construct__= 1 },
  },
  parent = Gtk324.GtkScaleButton,
  implement = {Gtk324.GtkActionable, Gtk324.GtkActivatable, Gtk324.GtkBuildable, Gtk324.GtkOrientable}, 
};

---------------------  GtkRadioButton
Gtk324.GtkRadioButton = {
  class = "GtkRadioButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new                           = { gencode = "gtk_radio_button_new((GSList*)({* this.group.value *}))", 
            params = { type = {"GSList*"}, 
                       name = {"group"} } },
    new_from_widget               = { gencode = "gtk_radio_button_new_from_widget((GtkRadioButton*)({* this.radio_group_member.value *}))", 
            params = { type = {}, name = {} } },
    new_with_label                = { gencode = "gtk_radio_button_new_with_label((GSList*)({* this.group.value *}), (const gchar*)({* this.label.value *}))", 
            params = { type = {"GSList*", "const gchar*"}, 
                       name = {"group", "label"} } },
    new_with_label_from_widget    = { gencode = "gtk_radio_button_new_with_label_from_widget((GtkRadioButton*)({* this.radio_group_member.value *}), (const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
    new_with_mnemonic             = { gencode = "gtk_radio_button_new_with_mnemonic((GSList*)({* this.group.value *}), (const gchar*)({* this.label.value *}))", 
            params = { type = {"GSList*", "const gchar*"}, 
                       name = {"group", "label"} } },
    new_with_mnemonic_from_widget = { gencode = "gtk_radio_button_new_with_mnemonic_from_widget((GtkRadioButton*)({* this.radio_group_member.value *}), (const gchar*)({* this.label.value *}))", 
            params = { type = {"const gchar*"}, 
                       name = {"label"} } },
  },
  ['virtual-method'] = { 
    -- 虚函数名称[- ==> _], 函数返回值, 函数参数列表
    group_changed = {"void", {"GtkRadioButton*"}, {"radio_button"} }, 
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    ['group-changed'] = {ret_type = "void", params = {type = {"GtkRadioButton*"}, name ={"radiobutton"}} }, 
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    group = {__type__="GtkRadioButton*" , __gencode__ = {"gtk_radio_button_set_group((GtkRadioButton*)({* id *}), (GSList*)({* property.value *}))"} },
  },
  parent = Gtk324.GtkCheckButton,
  implement = {Gtk324.GtkActionable, Gtk324.GtkActivatable, Gtk324.GtkBuildable}, 
};

---------------------  GtkRadioToolButton
Gtk324.GtkRadioToolButton = {
  class = "GtkRadioToolButton", 
  constructor = { 
    -- 名称[- ==> _], 
    new                        = { gencode = "gtk_radio_tool_button_new((GSList*)({* this.group.value *}))", 
            params = { type = {"GSList*"}, 
                       name = {"group"} } },
    new_from_stock             = { gencode = "gtk_radio_tool_button_new_from_stock((GSList*)({* this.group.value *}), (const gchar*)({* this['stock-id'].value *}))", 
            params = { type = {"GSList*", "const gchar*"}, 
                       name = {"group", "stock-id"} } },
    new_from_widget            = { gencode = "gtk_radio_tool_button_new_from_widget((GtkRadioToolButton*)({* this.group.value *}))", 
            params = { type = {"GtkRadioToolButton*"}, 
                       name = {"group"} } },
    new_with_stock_from_widget = { gencode = "gtk_radio_tool_button_new_with_stock_from_widget((GtkRadioToolButton*)({* this.group.value *}), (const gchar*)({* this['stock-id'].value *}))", 
            params = { type = {"GtkRadioToolButton*", "const gchar*"}, 
                       name = {"group", "stock-id"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    group = {__type__="GtkRadioToolButton*" , __gencode__ = {"gtk_radio_tool_button_set_group((GtkRadioToolButton*)({* id *}), (GSList*)({* property.value *}))"} },
  },
  parent = Gtk324.GtkToggleToolButton,
  implement = {Gtk324.GtkActionable, Gtk324.GtkActivatable, Gtk324.GtkBuildable}, 
};

----  [Gtk Classes] End ... 
----  [Gtk Enumerates] Start ... 
Gtk324.GtkEnumerationes = Gtk324.GtkEnumerationes or {}
do
    local merge_list = function (old_list)
        if Gtk324.GtkEnumerationes == nil then
            return old_list
        end
        for i, v in pairs(Gtk324.GtkEnumerationes) do
            old_list[i] = v
        end
        return old_list
    end
    Gtk324.GtkEnumerationes = merge_list({
        GtkAlign = {
        { macro = 'GTK_ALIGN_BASELINE', name = "baseline", nick = "baseline", value = "4"}, 
        { macro = 'GTK_ALIGN_CENTER'  , name = "center",   nick = "center",   value = "3"}, 
        { macro = 'GTK_ALIGN_END'     , name = "end",      nick = "end",      value = "2"}, 
        { macro = 'GTK_ALIGN_FILL'    , name = "fill",     nick = "fill",     value = "0"}, 
        { macro = 'GTK_ALIGN_START'   , name = "start",    nick = "start",    value = "1"}, 
    },
    GtkArrowPlacement = {
        { macro = 'GTK_ARROWS_BOTH' , name = "both",  nick = "both",  value = "0"}, 
        { macro = 'GTK_ARROWS_END'  , name = "end",   nick = "end",   value = "2"}, 
        { macro = 'GTK_ARROWS_START', name = "start", nick = "start", value = "1"}, 
    },
    GtkArrowType = {
        { macro = 'GTK_ARROW_DOWN' , name = "down",  nick = "down",  value = "1"}, 
        { macro = 'GTK_ARROW_LEFT' , name = "left",  nick = "left",  value = "2"}, 
        { macro = 'GTK_ARROW_NONE' , name = "none",  nick = "none",  value = "4"}, 
        { macro = 'GTK_ARROW_RIGHT', name = "right", nick = "right", value = "3"}, 
        { macro = 'GTK_ARROW_UP'   , name = "up",    nick = "up",    value = "0"}, 
    },
    GtkAssistantPageType = {
        { macro = 'GTK_ASSISTANT_PAGE_CONFIRM' , name = "confirm",  nick = "confirm",  value = "2"}, 
        { macro = 'GTK_ASSISTANT_PAGE_CONTENT' , name = "content",  nick = "content",  value = "0"}, 
        { macro = 'GTK_ASSISTANT_PAGE_CUSTOM'  , name = "custom",   nick = "custom",   value = "5"}, 
        { macro = 'GTK_ASSISTANT_PAGE_INTRO'   , name = "intro",    nick = "intro",    value = "1"}, 
        { macro = 'GTK_ASSISTANT_PAGE_PROGRESS', name = "progress", nick = "progress", value = "4"}, 
        { macro = 'GTK_ASSISTANT_PAGE_SUMMARY' , name = "summary",  nick = "summary",  value = "3"}, 
    },
    GtkBaselinePosition = {
        { macro = 'GTK_BASELINE_POSITION_BOTTOM', name = "bottom", nick = "bottom", value = "2"}, 
        { macro = 'GTK_BASELINE_POSITION_CENTER', name = "center", nick = "center", value = "1"}, 
        { macro = 'GTK_BASELINE_POSITION_TOP'   , name = "top",    nick = "top",    value = "0"}, 
    },
    GtkBorderStyle = {
        { macro = 'GTK_BORDER_STYLE_DASHED', name = "dashed", nick = "dashed", value = "6"}, 
        { macro = 'GTK_BORDER_STYLE_DOTTED', name = "dotted", nick = "dotted", value = "5"}, 
        { macro = 'GTK_BORDER_STYLE_DOUBLE', name = "double", nick = "double", value = "7"}, 
        { macro = 'GTK_BORDER_STYLE_GROOVE', name = "groove", nick = "groove", value = "8"}, 
        { macro = 'GTK_BORDER_STYLE_HIDDEN', name = "hidden", nick = "hidden", value = "4"}, 
        { macro = 'GTK_BORDER_STYLE_INSET' , name = "inset",  nick = "inset",  value = "2"}, 
        { macro = 'GTK_BORDER_STYLE_NONE'  , name = "none",   nick = "none",   value = "0"}, 
        { macro = 'GTK_BORDER_STYLE_OUTSET', name = "outset", nick = "outset", value = "3"}, 
        { macro = 'GTK_BORDER_STYLE_RIDGE' , name = "ridge",  nick = "ridge",  value = "9"}, 
        { macro = 'GTK_BORDER_STYLE_SOLID' , name = "solid",  nick = "solid",  value = "1"}, 
    },
    GtkBuilderError = {
        { macro = 'GTK_BUILDER_ERROR_DUPLICATE_ID'          , name = "duplicate_id",           nick = "duplicate-id",           value = "8"}, 
        { macro = 'GTK_BUILDER_ERROR_INVALID_ATTRIBUTE'     , name = "invalid_attribute",      nick = "invalid-attribute",      value = "3"}, 
        { macro = 'GTK_BUILDER_ERROR_INVALID_ID'            , name = "invalid_id",             nick = "invalid-id",             value = "13"}, 
        { macro = 'GTK_BUILDER_ERROR_INVALID_PROPERTY'      , name = "invalid_property",       nick = "invalid-property",       value = "11"}, 
        { macro = 'GTK_BUILDER_ERROR_INVALID_SIGNAL'        , name = "invalid_signal",         nick = "invalid-signal",         value = "12"}, 
        { macro = 'GTK_BUILDER_ERROR_INVALID_TAG'           , name = "invalid_tag",            nick = "invalid-tag",            value = "4"}, 
        { macro = 'GTK_BUILDER_ERROR_INVALID_TYPE_FUNCTION' , name = "invalid_type_function",  nick = "invalid-type-function",  value = "0"}, 
        { macro = 'GTK_BUILDER_ERROR_INVALID_VALUE'         , name = "invalid_value",          nick = "invalid-value",          value = "6"}, 
        { macro = 'GTK_BUILDER_ERROR_MISSING_ATTRIBUTE'     , name = "missing_attribute",      nick = "missing-attribute",      value = "2"}, 
        { macro = 'GTK_BUILDER_ERROR_MISSING_PROPERTY_VALUE', name = "missing_property_value", nick = "missing-property-value", value = "5"}, 
        { macro = 'GTK_BUILDER_ERROR_OBJECT_TYPE_REFUSED'   , name = "object_type_refused",    nick = "object-type-refused",    value = "9"}, 
        { macro = 'GTK_BUILDER_ERROR_TEMPLATE_MISMATCH'     , name = "template_mismatch",      nick = "template-mismatch",      value = "10"}, 
        { macro = 'GTK_BUILDER_ERROR_UNHANDLED_TAG'         , name = "unhandled_tag",          nick = "unhandled-tag",          value = "1"}, 
        { macro = 'GTK_BUILDER_ERROR_VERSION_MISMATCH'      , name = "version_mismatch",       nick = "version-mismatch",       value = "7"}, 
    },
    GtkButtonBoxStyle = {
        { macro = 'GTK_BUTTONBOX_CENTER', name = "center", nick = "center", value = "5"}, 
        { macro = 'GTK_BUTTONBOX_EDGE'  , name = "edge",   nick = "edge",   value = "2"}, 
        { macro = 'GTK_BUTTONBOX_END'   , name = "end",    nick = "end",    value = "4"}, 
        { macro = 'GTK_BUTTONBOX_EXPAND', name = "expand", nick = "expand", value = "6"}, 
        { macro = 'GTK_BUTTONBOX_SPREAD', name = "spread", nick = "spread", value = "1"}, 
        { macro = 'GTK_BUTTONBOX_START' , name = "start",  nick = "start",  value = "3"}, 
    },
    GtkButtonRole = {
        { macro = 'GTK_BUTTON_ROLE_CHECK' , name = "check",  nick = "check",  value = "1"}, 
        { macro = 'GTK_BUTTON_ROLE_NORMAL', name = "normal", nick = "normal", value = "0"}, 
        { macro = 'GTK_BUTTON_ROLE_RADIO' , name = "radio",  nick = "radio",  value = "2"}, 
    },
    GtkButtonsType = {
        { macro = 'GTK_BUTTONS_CANCEL'   , name = "cancel",    nick = "cancel",    value = "3"}, 
        { macro = 'GTK_BUTTONS_CLOSE'    , name = "close",     nick = "close",     value = "2"}, 
        { macro = 'GTK_BUTTONS_NONE'     , name = "none",      nick = "none",      value = "0"}, 
        { macro = 'GTK_BUTTONS_OK'       , name = "ok",        nick = "ok",        value = "1"}, 
        { macro = 'GTK_BUTTONS_OK_CANCEL', name = "ok_cancel", nick = "ok-cancel", value = "5"}, 
        { macro = 'GTK_BUTTONS_YES_NO'   , name = "yes_no",    nick = "yes-no",    value = "4"}, 
    },
    GtkCellRendererAccelMode = {
        { macro = 'GTK_CELL_RENDERER_ACCEL_MODE_GTK'  , name = "gtk",   nick = "gtk",   value = "0"}, 
        { macro = 'GTK_CELL_RENDERER_ACCEL_MODE_OTHER', name = "other", nick = "other", value = "1"}, 
    },
    GtkCellRendererMode = {
        { macro = 'GTK_CELL_RENDERER_MODE_ACTIVATABLE', name = "activatable", nick = "activatable", value = "1"}, 
        { macro = 'GTK_CELL_RENDERER_MODE_EDITABLE'   , name = "editable",    nick = "editable",    value = "2"}, 
        { macro = 'GTK_CELL_RENDERER_MODE_INERT'      , name = "inert",       nick = "inert",       value = "0"}, 
    },
    GtkCornerType = {
        { macro = 'GTK_CORNER_BOTTOM_LEFT' , name = "bottom_left",  nick = "bottom-left",  value = "1"}, 
        { macro = 'GTK_CORNER_BOTTOM_RIGHT', name = "bottom_right", nick = "bottom-right", value = "3"}, 
        { macro = 'GTK_CORNER_TOP_LEFT'    , name = "top_left",     nick = "top-left",     value = "0"}, 
        { macro = 'GTK_CORNER_TOP_RIGHT'   , name = "top_right",    nick = "top-right",    value = "2"}, 
    },
    GtkCssProviderError = {
        { macro = 'GTK_CSS_PROVIDER_ERROR_DEPRECATED'   , name = "deprecated",    nick = "deprecated",    value = "4"}, 
        { macro = 'GTK_CSS_PROVIDER_ERROR_FAILED'       , name = "failed",        nick = "failed",        value = "0"}, 
        { macro = 'GTK_CSS_PROVIDER_ERROR_IMPORT'       , name = "import",        nick = "import",        value = "2"}, 
        { macro = 'GTK_CSS_PROVIDER_ERROR_NAME'         , name = "name",          nick = "name",          value = "3"}, 
        { macro = 'GTK_CSS_PROVIDER_ERROR_SYNTAX'       , name = "syntax",        nick = "syntax",        value = "1"}, 
        { macro = 'GTK_CSS_PROVIDER_ERROR_UNKNOWN_VALUE', name = "unknown_value", nick = "unknown-value", value = "5"}, 
    },
    GtkCssSectionType = {
        { macro = 'GTK_CSS_SECTION_BINDING_SET'     , name = "binding_set",      nick = "binding-set",      value = "3"}, 
        { macro = 'GTK_CSS_SECTION_COLOR_DEFINITION', name = "color_definition", nick = "color-definition", value = "2"}, 
        { macro = 'GTK_CSS_SECTION_DECLARATION'     , name = "declaration",      nick = "declaration",      value = "6"}, 
        { macro = 'GTK_CSS_SECTION_DOCUMENT'        , name = "document",         nick = "document",         value = "0"}, 
        { macro = 'GTK_CSS_SECTION_IMPORT'          , name = "import",           nick = "import",           value = "1"}, 
        { macro = 'GTK_CSS_SECTION_KEYFRAMES'       , name = "keyframes",        nick = "keyframes",        value = "8"}, 
        { macro = 'GTK_CSS_SECTION_RULESET'         , name = "ruleset",          nick = "ruleset",          value = "4"}, 
        { macro = 'GTK_CSS_SECTION_SELECTOR'        , name = "selector",         nick = "selector",         value = "5"}, 
        { macro = 'GTK_CSS_SECTION_VALUE'           , name = "value",            nick = "value",            value = "7"}, 
    },
    GtkDeleteType = {
        { macro = 'GTK_DELETE_CHARS'            , name = "chars",             nick = "chars",             value = "0"}, 
        { macro = 'GTK_DELETE_DISPLAY_LINE_ENDS', name = "display_line_ends", nick = "display-line-ends", value = "4"}, 
        { macro = 'GTK_DELETE_DISPLAY_LINES'    , name = "display_lines",     nick = "display-lines",     value = "3"}, 
        { macro = 'GTK_DELETE_PARAGRAPH_ENDS'   , name = "paragraph_ends",    nick = "paragraph-ends",    value = "5"}, 
        { macro = 'GTK_DELETE_PARAGRAPHS'       , name = "paragraphs",        nick = "paragraphs",        value = "6"}, 
        { macro = 'GTK_DELETE_WHITESPACE'       , name = "whitespace",        nick = "whitespace",        value = "7"}, 
        { macro = 'GTK_DELETE_WORD_ENDS'        , name = "word_ends",         nick = "word-ends",         value = "1"}, 
        { macro = 'GTK_DELETE_WORDS'            , name = "words",             nick = "words",             value = "2"}, 
    },
    GtkDirectionType = {
        { macro = 'GTK_DIR_DOWN'        , name = "down",         nick = "down",         value = "3"}, 
        { macro = 'GTK_DIR_LEFT'        , name = "left",         nick = "left",         value = "4"}, 
        { macro = 'GTK_DIR_RIGHT'       , name = "right",        nick = "right",        value = "5"}, 
        { macro = 'GTK_DIR_TAB_BACKWARD', name = "tab_backward", nick = "tab-backward", value = "1"}, 
        { macro = 'GTK_DIR_TAB_FORWARD' , name = "tab_forward",  nick = "tab-forward",  value = "0"}, 
        { macro = 'GTK_DIR_UP'          , name = "up",           nick = "up",           value = "2"}, 
    },
    GtkDragResult = {
        { macro = 'GTK_DRAG_RESULT_ERROR'          , name = "error",           nick = "error",           value = "5"}, 
        { macro = 'GTK_DRAG_RESULT_GRAB_BROKEN'    , name = "grab_broken",     nick = "grab-broken",     value = "4"}, 
        { macro = 'GTK_DRAG_RESULT_NO_TARGET'      , name = "no_target",       nick = "no-target",       value = "1"}, 
        { macro = 'GTK_DRAG_RESULT_SUCCESS'        , name = "success",         nick = "success",         value = "0"}, 
        { macro = 'GTK_DRAG_RESULT_TIMEOUT_EXPIRED', name = "timeout_expired", nick = "timeout-expired", value = "3"}, 
        { macro = 'GTK_DRAG_RESULT_USER_CANCELLED' , name = "user_cancelled",  nick = "user-cancelled",  value = "2"}, 
    },
    GtkEntryIconPosition = {
        { macro = 'GTK_ENTRY_ICON_PRIMARY'  , name = "primary",   nick = "primary",   value = "0"}, 
        { macro = 'GTK_ENTRY_ICON_SECONDARY', name = "secondary", nick = "secondary", value = "1"}, 
    },
    GtkEventSequenceState = {
        { macro = 'GTK_EVENT_SEQUENCE_CLAIMED', name = "claimed", nick = "claimed", value = "1"}, 
        { macro = 'GTK_EVENT_SEQUENCE_DENIED' , name = "denied",  nick = "denied",  value = "2"}, 
        { macro = 'GTK_EVENT_SEQUENCE_NONE'   , name = "none",    nick = "none",    value = "0"}, 
    },
    GtkExpanderStyle = {
        { macro = 'GTK_EXPANDER_COLLAPSED'     , name = "collapsed",      nick = "collapsed",      value = "0"}, 
        { macro = 'GTK_EXPANDER_EXPANDED'      , name = "expanded",       nick = "expanded",       value = "3"}, 
        { macro = 'GTK_EXPANDER_SEMI_COLLAPSED', name = "semi_collapsed", nick = "semi-collapsed", value = "1"}, 
        { macro = 'GTK_EXPANDER_SEMI_EXPANDED' , name = "semi_expanded",  nick = "semi-expanded",  value = "2"}, 
    },
    GtkFileChooserAction = {
        { macro = 'GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER', name = "create_folder", nick = "create-folder", value = "3"}, 
        { macro = 'GTK_FILE_CHOOSER_ACTION_OPEN'         , name = "open",          nick = "open",          value = "0"}, 
        { macro = 'GTK_FILE_CHOOSER_ACTION_SAVE'         , name = "save",          nick = "save",          value = "1"}, 
        { macro = 'GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER', name = "select_folder", nick = "select-folder", value = "2"}, 
    },
    GtkFileChooserConfirmation = {
        { macro = 'GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME', name = "accept_filename", nick = "accept-filename", value = "1"}, 
        { macro = 'GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM'        , name = "confirm",         nick = "confirm",         value = "0"}, 
        { macro = 'GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN'   , name = "select_again",    nick = "select-again",    value = "2"}, 
    },
    GtkFileChooserError = {
        { macro = 'GTK_FILE_CHOOSER_ERROR_ALREADY_EXISTS'     , name = "already_exists",      nick = "already-exists",      value = "2"}, 
        { macro = 'GTK_FILE_CHOOSER_ERROR_BAD_FILENAME'       , name = "bad_filename",        nick = "bad-filename",        value = "1"}, 
        { macro = 'GTK_FILE_CHOOSER_ERROR_INCOMPLETE_HOSTNAME', name = "incomplete_hostname", nick = "incomplete-hostname", value = "3"}, 
        { macro = 'GTK_FILE_CHOOSER_ERROR_NONEXISTENT'        , name = "nonexistent",         nick = "nonexistent",         value = "0"}, 
    },
    GtkIMPreeditStyle = {
        { macro = 'GTK_IM_PREEDIT_CALLBACK', name = "callback", nick = "callback", value = "1"}, 
        { macro = 'GTK_IM_PREEDIT_NONE'    , name = "none",     nick = "none",     value = "2"}, 
        { macro = 'GTK_IM_PREEDIT_NOTHING' , name = "nothing",  nick = "nothing",  value = "0"}, 
    },
    GtkIMStatusStyle = {
        { macro = 'GTK_IM_STATUS_CALLBACK', name = "callback", nick = "callback", value = "1"}, 
        { macro = 'GTK_IM_STATUS_NONE'    , name = "none",     nick = "none",     value = "2"}, 
        { macro = 'GTK_IM_STATUS_NOTHING' , name = "nothing",  nick = "nothing",  value = "0"}, 
    },
    GtkIconSize = {
        { macro = 'GTK_ICON_SIZE_BUTTON'       , name = "button",        nick = "button",        value = "4"}, 
        { macro = 'GTK_ICON_SIZE_DIALOG'       , name = "dialog",        nick = "dialog",        value = "6"}, 
        { macro = 'GTK_ICON_SIZE_DND'          , name = "dnd",           nick = "dnd",           value = "5"}, 
        { macro = 'GTK_ICON_SIZE_INVALID'      , name = "invalid",       nick = "invalid",       value = "0"}, 
        { macro = 'GTK_ICON_SIZE_LARGE_TOOLBAR', name = "large_toolbar", nick = "large-toolbar", value = "3"}, 
        { macro = 'GTK_ICON_SIZE_MENU'         , name = "menu",          nick = "menu",          value = "1"}, 
        { macro = 'GTK_ICON_SIZE_SMALL_TOOLBAR', name = "small_toolbar", nick = "small-toolbar", value = "2"}, 
    },
    GtkIconThemeError = {
        { macro = 'GTK_ICON_THEME_FAILED'   , name = "failed",    nick = "failed",    value = "1"}, 
        { macro = 'GTK_ICON_THEME_NOT_FOUND', name = "not_found", nick = "not-found", value = "0"}, 
    },
    GtkIconViewDropPosition = {
        { macro = 'GTK_ICON_VIEW_DROP_ABOVE', name = "drop_above", nick = "drop-above", value = "4"}, 
        { macro = 'GTK_ICON_VIEW_DROP_BELOW', name = "drop_below", nick = "drop-below", value = "5"}, 
        { macro = 'GTK_ICON_VIEW_DROP_INTO' , name = "drop_into",  nick = "drop-into",  value = "1"}, 
        { macro = 'GTK_ICON_VIEW_DROP_LEFT' , name = "drop_left",  nick = "drop-left",  value = "2"}, 
        { macro = 'GTK_ICON_VIEW_DROP_RIGHT', name = "drop_right", nick = "drop-right", value = "3"}, 
        { macro = 'GTK_ICON_VIEW_NO_DROP'   , name = "no_drop",    nick = "no-drop",    value = "0"}, 
    },
    GtkImageType = {
        { macro = 'GTK_IMAGE_ANIMATION', name = "animation", nick = "animation", value = "4"}, 
        { macro = 'GTK_IMAGE_EMPTY'    , name = "empty",     nick = "empty",     value = "0"}, 
        { macro = 'GTK_IMAGE_GICON'    , name = "gicon",     nick = "gicon",     value = "6"}, 
        { macro = 'GTK_IMAGE_ICON_NAME', name = "icon_name", nick = "icon-name", value = "5"}, 
        { macro = 'GTK_IMAGE_ICON_SET' , name = "icon_set",  nick = "icon-set",  value = "3"}, 
        { macro = 'GTK_IMAGE_PIXBUF'   , name = "pixbuf",    nick = "pixbuf",    value = "1"}, 
        { macro = 'GTK_IMAGE_STOCK'    , name = "stock",     nick = "stock",     value = "2"}, 
        { macro = 'GTK_IMAGE_SURFACE'  , name = "surface",   nick = "surface",   value = "7"}, 
    },
    GtkInputPurpose = {
        { macro = 'GTK_INPUT_PURPOSE_ALPHA'    , name = "alpha",     nick = "alpha",     value = "1"}, 
        { macro = 'GTK_INPUT_PURPOSE_DIGITS'   , name = "digits",    nick = "digits",    value = "2"}, 
        { macro = 'GTK_INPUT_PURPOSE_EMAIL'    , name = "email",     nick = "email",     value = "6"}, 
        { macro = 'GTK_INPUT_PURPOSE_FREE_FORM', name = "free_form", nick = "free-form", value = "0"}, 
        { macro = 'GTK_INPUT_PURPOSE_NAME'     , name = "name",      nick = "name",      value = "7"}, 
        { macro = 'GTK_INPUT_PURPOSE_NUMBER'   , name = "number",    nick = "number",    value = "3"}, 
        { macro = 'GTK_INPUT_PURPOSE_PASSWORD' , name = "password",  nick = "password",  value = "8"}, 
        { macro = 'GTK_INPUT_PURPOSE_PHONE'    , name = "phone",     nick = "phone",     value = "4"}, 
        { macro = 'GTK_INPUT_PURPOSE_PIN'      , name = "pin",       nick = "pin",       value = "9"}, 
        { macro = 'GTK_INPUT_PURPOSE_TERMINAL' , name = "terminal",  nick = "terminal",  value = "10"}, 
        { macro = 'GTK_INPUT_PURPOSE_URL'      , name = "url",       nick = "url",       value = "5"}, 
    },
    GtkJustification = {
        { macro = 'GTK_JUSTIFY_CENTER', name = "center", nick = "center", value = "2"}, 
        { macro = 'GTK_JUSTIFY_FILL'  , name = "fill",   nick = "fill",   value = "3"}, 
        { macro = 'GTK_JUSTIFY_LEFT'  , name = "left",   nick = "left",   value = "0"}, 
        { macro = 'GTK_JUSTIFY_RIGHT' , name = "right",  nick = "right",  value = "1"}, 
    },
    GtkLevelBarMode = {
        { macro = 'GTK_LEVEL_BAR_MODE_CONTINUOUS', name = "continuous", nick = "continuous", value = "0"}, 
        { macro = 'GTK_LEVEL_BAR_MODE_DISCRETE'  , name = "discrete",   nick = "discrete",   value = "1"}, 
    },
    GtkLicense = {
        { macro = 'GTK_LICENSE_AGPL_3_0'     , name = "agpl_3_0",      nick = "agpl-3-0",      value = "13"}, 
        { macro = 'GTK_LICENSE_AGPL_3_0_ONLY', name = "agpl_3_0_only", nick = "agpl-3-0-only", value = "14"}, 
        { macro = 'GTK_LICENSE_APACHE_2_0'   , name = "apache_2_0",    nick = "apache-2-0",    value = "16"}, 
        { macro = 'GTK_LICENSE_ARTISTIC'     , name = "artistic",      nick = "artistic",      value = "8"}, 
        { macro = 'GTK_LICENSE_BSD'          , name = "bsd",           nick = "bsd",           value = "6"}, 
        { macro = 'GTK_LICENSE_BSD_3'        , name = "bsd_3",         nick = "bsd-3",         value = "15"}, 
        { macro = 'GTK_LICENSE_CUSTOM'       , name = "custom",        nick = "custom",        value = "1"}, 
        { macro = 'GTK_LICENSE_GPL_2_0'      , name = "gpl_2_0",       nick = "gpl-2-0",       value = "2"}, 
        { macro = 'GTK_LICENSE_GPL_2_0_ONLY' , name = "gpl_2_0_only",  nick = "gpl-2-0-only",  value = "9"}, 
        { macro = 'GTK_LICENSE_GPL_3_0'      , name = "gpl_3_0",       nick = "gpl-3-0",       value = "3"}, 
        { macro = 'GTK_LICENSE_GPL_3_0_ONLY' , name = "gpl_3_0_only",  nick = "gpl-3-0-only",  value = "10"}, 
        { macro = 'GTK_LICENSE_LGPL_2_1'     , name = "lgpl_2_1",      nick = "lgpl-2-1",      value = "4"}, 
        { macro = 'GTK_LICENSE_LGPL_2_1_ONLY', name = "lgpl_2_1_only", nick = "lgpl-2-1-only", value = "11"}, 
        { macro = 'GTK_LICENSE_LGPL_3_0'     , name = "lgpl_3_0",      nick = "lgpl-3-0",      value = "5"}, 
        { macro = 'GTK_LICENSE_LGPL_3_0_ONLY', name = "lgpl_3_0_only", nick = "lgpl-3-0-only", value = "12"}, 
        { macro = 'GTK_LICENSE_MIT_X11'      , name = "mit_x11",       nick = "mit-x11",       value = "7"}, 
        { macro = 'GTK_LICENSE_MPL_2_0'      , name = "mpl_2_0",       nick = "mpl-2-0",       value = "17"}, 
        { macro = 'GTK_LICENSE_UNKNOWN'      , name = "unknown",       nick = "unknown",       value = "0"}, 
    },
    GtkMenuDirectionType = {
        { macro = 'GTK_MENU_DIR_CHILD' , name = "child",  nick = "child",  value = "1"}, 
        { macro = 'GTK_MENU_DIR_NEXT'  , name = "next",   nick = "next",   value = "2"}, 
        { macro = 'GTK_MENU_DIR_PARENT', name = "parent", nick = "parent", value = "0"}, 
        { macro = 'GTK_MENU_DIR_PREV'  , name = "prev",   nick = "prev",   value = "3"}, 
    },
    GtkMessageType = {
        { macro = 'GTK_MESSAGE_ERROR'   , name = "error",    nick = "error",    value = "3"}, 
        { macro = 'GTK_MESSAGE_INFO'    , name = "info",     nick = "info",     value = "0"}, 
        { macro = 'GTK_MESSAGE_OTHER'   , name = "other",    nick = "other",    value = "4"}, 
        { macro = 'GTK_MESSAGE_QUESTION', name = "question", nick = "question", value = "2"}, 
        { macro = 'GTK_MESSAGE_WARNING' , name = "warning",  nick = "warning",  value = "1"}, 
    },
    GtkMovementStep = {
        { macro = 'GTK_MOVEMENT_BUFFER_ENDS'      , name = "buffer_ends",       nick = "buffer-ends",       value = "8"}, 
        { macro = 'GTK_MOVEMENT_DISPLAY_LINE_ENDS', name = "display_line_ends", nick = "display-line-ends", value = "4"}, 
        { macro = 'GTK_MOVEMENT_DISPLAY_LINES'    , name = "display_lines",     nick = "display-lines",     value = "3"}, 
        { macro = 'GTK_MOVEMENT_HORIZONTAL_PAGES' , name = "horizontal_pages",  nick = "horizontal-pages",  value = "9"}, 
        { macro = 'GTK_MOVEMENT_LOGICAL_POSITIONS', name = "logical_positions", nick = "logical-positions", value = "0"}, 
        { macro = 'GTK_MOVEMENT_PAGES'            , name = "pages",             nick = "pages",             value = "7"}, 
        { macro = 'GTK_MOVEMENT_PARAGRAPH_ENDS'   , name = "paragraph_ends",    nick = "paragraph-ends",    value = "6"}, 
        { macro = 'GTK_MOVEMENT_PARAGRAPHS'       , name = "paragraphs",        nick = "paragraphs",        value = "5"}, 
        { macro = 'GTK_MOVEMENT_VISUAL_POSITIONS' , name = "visual_positions",  nick = "visual-positions",  value = "1"}, 
        { macro = 'GTK_MOVEMENT_WORDS'            , name = "words",             nick = "words",             value = "2"}, 
    },
    GtkNotebookTab = {
        { macro = 'GTK_NOTEBOOK_TAB_FIRST', name = "first", nick = "first", value = "0"}, 
        { macro = 'GTK_NOTEBOOK_TAB_LAST' , name = "last",  nick = "last",  value = "1"}, 
    },
    GtkNumberUpLayout = {
        { macro = 'GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_LEFT_TO_RIGHT', name = "btlr", nick = "btlr", value = "6"}, 
        { macro = 'GTK_NUMBER_UP_LAYOUT_BOTTOM_TO_TOP_RIGHT_TO_LEFT', name = "btrl", nick = "btrl", value = "7"}, 
        { macro = 'GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_BOTTOM_TO_TOP', name = "lrbt", nick = "lrbt", value = "1"}, 
        { macro = 'GTK_NUMBER_UP_LAYOUT_LEFT_TO_RIGHT_TOP_TO_BOTTOM', name = "lrtb", nick = "lrtb", value = "0"}, 
        { macro = 'GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_BOTTOM_TO_TOP', name = "rlbt", nick = "rlbt", value = "3"}, 
        { macro = 'GTK_NUMBER_UP_LAYOUT_RIGHT_TO_LEFT_TOP_TO_BOTTOM', name = "rltb", nick = "rltb", value = "2"}, 
        { macro = 'GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_LEFT_TO_RIGHT', name = "tblr", nick = "tblr", value = "4"}, 
        { macro = 'GTK_NUMBER_UP_LAYOUT_TOP_TO_BOTTOM_RIGHT_TO_LEFT', name = "tbrl", nick = "tbrl", value = "5"}, 
    },
    GtkOrientation = {
        { macro = 'GTK_ORIENTATION_HORIZONTAL', name = "horizontal", nick = "horizontal", value = "0"}, 
        { macro = 'GTK_ORIENTATION_VERTICAL'  , name = "vertical",   nick = "vertical",   value = "1"}, 
    },
    GtkPackDirection = {
        { macro = 'GTK_PACK_DIRECTION_BTT', name = "btt", nick = "btt", value = "3"}, 
        { macro = 'GTK_PACK_DIRECTION_LTR', name = "ltr", nick = "ltr", value = "0"}, 
        { macro = 'GTK_PACK_DIRECTION_RTL', name = "rtl", nick = "rtl", value = "1"}, 
        { macro = 'GTK_PACK_DIRECTION_TTB', name = "ttb", nick = "ttb", value = "2"}, 
    },
    GtkPackType = {
        { macro = 'GTK_PACK_END'  , name = "end",   nick = "end",   value = "1"}, 
        { macro = 'GTK_PACK_START', name = "start", nick = "start", value = "0"}, 
    },
    GtkPadActionType = {
        { macro = 'GTK_PAD_ACTION_BUTTON', name = "button", nick = "button", value = "0"}, 
        { macro = 'GTK_PAD_ACTION_RING'  , name = "ring",   nick = "ring",   value = "1"}, 
        { macro = 'GTK_PAD_ACTION_STRIP' , name = "strip",  nick = "strip",  value = "2"}, 
    },
    GtkPageOrientation = {
        { macro = 'GTK_PAGE_ORIENTATION_LANDSCAPE'        , name = "landscape",         nick = "landscape",         value = "1"}, 
        { macro = 'GTK_PAGE_ORIENTATION_PORTRAIT'         , name = "portrait",          nick = "portrait",          value = "0"}, 
        { macro = 'GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE', name = "reverse_landscape", nick = "reverse-landscape", value = "3"}, 
        { macro = 'GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT' , name = "reverse_portrait",  nick = "reverse-portrait",  value = "2"}, 
    },
    GtkPageSet = {
        { macro = 'GTK_PAGE_SET_ALL' , name = "all",  nick = "all",  value = "0"}, 
        { macro = 'GTK_PAGE_SET_EVEN', name = "even", nick = "even", value = "1"}, 
        { macro = 'GTK_PAGE_SET_ODD' , name = "odd",  nick = "odd",  value = "2"}, 
    },
    GtkPanDirection = {
        { macro = 'GTK_PAN_DIRECTION_DOWN' , name = "down",  nick = "down",  value = "3"}, 
        { macro = 'GTK_PAN_DIRECTION_LEFT' , name = "left",  nick = "left",  value = "0"}, 
        { macro = 'GTK_PAN_DIRECTION_RIGHT', name = "right", nick = "right", value = "1"}, 
        { macro = 'GTK_PAN_DIRECTION_UP'   , name = "up",    nick = "up",    value = "2"}, 
    },
    GtkPathPriorityType = {
        { macro = 'GTK_PATH_PRIO_APPLICATION', name = "application", nick = "application", value = "8"}, 
        { macro = 'GTK_PATH_PRIO_GTK'        , name = "gtk",         nick = "gtk",         value = "4"}, 
        { macro = 'GTK_PATH_PRIO_HIGHEST'    , name = "highest",     nick = "highest",     value = "15"}, 
        { macro = 'GTK_PATH_PRIO_LOWEST'     , name = "lowest",      nick = "lowest",      value = "0"}, 
        { macro = 'GTK_PATH_PRIO_RC'         , name = "rc",          nick = "rc",          value = "12"}, 
        { macro = 'GTK_PATH_PRIO_THEME'      , name = "theme",       nick = "theme",       value = "10"}, 
    },
    GtkPathType = {
        { macro = 'GTK_PATH_CLASS'       , name = "class",        nick = "class",        value = "2"}, 
        { macro = 'GTK_PATH_WIDGET'      , name = "widget",       nick = "widget",       value = "0"}, 
        { macro = 'GTK_PATH_WIDGET_CLASS', name = "widget_class", nick = "widget-class", value = "1"}, 
    },
    GtkPolicyType = {
        { macro = 'GTK_POLICY_ALWAYS'   , name = "always",    nick = "always",    value = "0"}, 
        { macro = 'GTK_POLICY_AUTOMATIC', name = "automatic", nick = "automatic", value = "1"}, 
        { macro = 'GTK_POLICY_EXTERNAL' , name = "external",  nick = "external",  value = "3"}, 
        { macro = 'GTK_POLICY_NEVER'    , name = "never",     nick = "never",     value = "2"}, 
    },
    GtkPopoverConstraint = {
        { macro = 'GTK_POPOVER_CONSTRAINT_NONE'  , name = "none",   nick = "none",   value = "0"}, 
        { macro = 'GTK_POPOVER_CONSTRAINT_WINDOW', name = "window", nick = "window", value = "1"}, 
    },
    GtkPositionType = {
        { macro = 'GTK_POS_BOTTOM', name = "bottom", nick = "bottom", value = "3"}, 
        { macro = 'GTK_POS_LEFT'  , name = "left",   nick = "left",   value = "0"}, 
        { macro = 'GTK_POS_RIGHT' , name = "right",  nick = "right",  value = "1"}, 
        { macro = 'GTK_POS_TOP'   , name = "top",    nick = "top",    value = "2"}, 
    },
    GtkPrintDuplex = {
        { macro = 'GTK_PRINT_DUPLEX_HORIZONTAL', name = "horizontal", nick = "horizontal", value = "1"}, 
        { macro = 'GTK_PRINT_DUPLEX_SIMPLEX'   , name = "simplex",    nick = "simplex",    value = "0"}, 
        { macro = 'GTK_PRINT_DUPLEX_VERTICAL'  , name = "vertical",   nick = "vertical",   value = "2"}, 
    },
    GtkPrintError = {
        { macro = 'GTK_PRINT_ERROR_GENERAL'       , name = "general",        nick = "general",        value = "0"}, 
        { macro = 'GTK_PRINT_ERROR_INTERNAL_ERROR', name = "internal_error", nick = "internal-error", value = "1"}, 
        { macro = 'GTK_PRINT_ERROR_INVALID_FILE'  , name = "invalid_file",   nick = "invalid-file",   value = "3"}, 
        { macro = 'GTK_PRINT_ERROR_NOMEM'         , name = "nomem",          nick = "nomem",          value = "2"}, 
    },
    GtkPrintOperationAction = {
        { macro = 'GTK_PRINT_OPERATION_ACTION_EXPORT'      , name = "export",       nick = "export",       value = "3"}, 
        { macro = 'GTK_PRINT_OPERATION_ACTION_PREVIEW'     , name = "preview",      nick = "preview",      value = "2"}, 
        { macro = 'GTK_PRINT_OPERATION_ACTION_PRINT'       , name = "print",        nick = "print",        value = "1"}, 
        { macro = 'GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG', name = "print_dialog", nick = "print-dialog", value = "0"}, 
    },
    GtkPrintOperationResult = {
        { macro = 'GTK_PRINT_OPERATION_RESULT_APPLY'      , name = "apply",       nick = "apply",       value = "1"}, 
        { macro = 'GTK_PRINT_OPERATION_RESULT_CANCEL'     , name = "cancel",      nick = "cancel",      value = "2"}, 
        { macro = 'GTK_PRINT_OPERATION_RESULT_ERROR'      , name = "error",       nick = "error",       value = "0"}, 
        { macro = 'GTK_PRINT_OPERATION_RESULT_IN_PROGRESS', name = "in_progress", nick = "in-progress", value = "3"}, 
    },
    GtkPrintPages = {
        { macro = 'GTK_PRINT_PAGES_ALL'      , name = "all",       nick = "all",       value = "0"}, 
        { macro = 'GTK_PRINT_PAGES_CURRENT'  , name = "current",   nick = "current",   value = "1"}, 
        { macro = 'GTK_PRINT_PAGES_RANGES'   , name = "ranges",    nick = "ranges",    value = "2"}, 
        { macro = 'GTK_PRINT_PAGES_SELECTION', name = "selection", nick = "selection", value = "3"}, 
    },
    GtkPrintQuality = {
        { macro = 'GTK_PRINT_QUALITY_DRAFT' , name = "draft",  nick = "draft",  value = "3"}, 
        { macro = 'GTK_PRINT_QUALITY_HIGH'  , name = "high",   nick = "high",   value = "2"}, 
        { macro = 'GTK_PRINT_QUALITY_LOW'   , name = "low",    nick = "low",    value = "0"}, 
        { macro = 'GTK_PRINT_QUALITY_NORMAL', name = "normal", nick = "normal", value = "1"}, 
    },
    GtkPrintStatus = {
        { macro = 'GTK_PRINT_STATUS_FINISHED'        , name = "finished",         nick = "finished",         value = "7"}, 
        { macro = 'GTK_PRINT_STATUS_FINISHED_ABORTED', name = "finished_aborted", nick = "finished-aborted", value = "8"}, 
        { macro = 'GTK_PRINT_STATUS_GENERATING_DATA' , name = "generating_data",  nick = "generating-data",  value = "2"}, 
        { macro = 'GTK_PRINT_STATUS_INITIAL'         , name = "initial",          nick = "initial",          value = "0"}, 
        { macro = 'GTK_PRINT_STATUS_PENDING'         , name = "pending",          nick = "pending",          value = "4"}, 
        { macro = 'GTK_PRINT_STATUS_PENDING_ISSUE'   , name = "pending_issue",    nick = "pending-issue",    value = "5"}, 
        { macro = 'GTK_PRINT_STATUS_PREPARING'       , name = "preparing",        nick = "preparing",        value = "1"}, 
        { macro = 'GTK_PRINT_STATUS_PRINTING'        , name = "printing",         nick = "printing",         value = "6"}, 
        { macro = 'GTK_PRINT_STATUS_SENDING_DATA'    , name = "sending_data",     nick = "sending-data",     value = "3"}, 
    },
    GtkPropagationPhase = {
        { macro = 'GTK_PHASE_BUBBLE' , name = "bubble",  nick = "bubble",  value = "2"}, 
        { macro = 'GTK_PHASE_CAPTURE', name = "capture", nick = "capture", value = "1"}, 
        { macro = 'GTK_PHASE_NONE'   , name = "none",    nick = "none",    value = "0"}, 
        { macro = 'GTK_PHASE_TARGET' , name = "target",  nick = "target",  value = "3"}, 
    },
    GtkRcTokenType = {
        { macro = 'GTK_RC_TOKEN_ACTIVE'        , name = "active",         nick = "active",         value = "273"}, 
        { macro = 'GTK_RC_TOKEN_APPLICATION'   , name = "application",    nick = "application",    value = "296"}, 
        { macro = 'GTK_RC_TOKEN_BASE'          , name = "base",           nick = "base",           value = "280"}, 
        { macro = 'GTK_RC_TOKEN_BG'            , name = "bg",             nick = "bg",             value = "278"}, 
        { macro = 'GTK_RC_TOKEN_BG_PIXMAP'     , name = "bg_pixmap",      nick = "bg-pixmap",      value = "286"}, 
        { macro = 'GTK_RC_TOKEN_BIND'          , name = "bind",           nick = "bind",           value = "290"}, 
        { macro = 'GTK_RC_TOKEN_BINDING'       , name = "binding",        nick = "binding",        value = "289"}, 
        { macro = 'GTK_RC_TOKEN_CLASS'         , name = "class",          nick = "class",          value = "293"}, 
        { macro = 'GTK_RC_TOKEN_COLOR'         , name = "color",          nick = "color",          value = "307"}, 
        { macro = 'GTK_RC_TOKEN_ENGINE'        , name = "engine",         nick = "engine",         value = "300"}, 
        { macro = 'GTK_RC_TOKEN_FG'            , name = "fg",             nick = "fg",             value = "277"}, 
        { macro = 'GTK_RC_TOKEN_FONT'          , name = "font",           nick = "font",           value = "283"}, 
        { macro = 'GTK_RC_TOKEN_FONT_NAME'     , name = "font_name",      nick = "font-name",      value = "285"}, 
        { macro = 'GTK_RC_TOKEN_FONTSET'       , name = "fontset",        nick = "fontset",        value = "284"}, 
        { macro = 'GTK_RC_TOKEN_GTK'           , name = "gtk",            nick = "gtk",            value = "295"}, 
        { macro = 'GTK_RC_TOKEN_HIGHEST'       , name = "highest",        nick = "highest",        value = "299"}, 
        { macro = 'GTK_RC_TOKEN_IM_MODULE_FILE', name = "im_module_file", nick = "im-module-file", value = "303"}, 
        { macro = 'GTK_RC_TOKEN_IM_MODULE_PATH', name = "im_module_path", nick = "im-module-path", value = "302"}, 
        { macro = 'GTK_RC_TOKEN_INCLUDE'       , name = "include",        nick = "include",        value = "271"}, 
        { macro = 'GTK_RC_TOKEN_INSENSITIVE'   , name = "insensitive",    nick = "insensitive",    value = "276"}, 
        { macro = 'GTK_RC_TOKEN_INVALID'       , name = "invalid",        nick = "invalid",        value = "270"}, 
        { macro = 'GTK_RC_TOKEN_LAST'          , name = "last",           nick = "last",           value = "309"}, 
        { macro = 'GTK_RC_TOKEN_LOWEST'        , name = "lowest",         nick = "lowest",         value = "294"}, 
        { macro = 'GTK_RC_TOKEN_LTR'           , name = "ltr",            nick = "ltr",            value = "305"}, 
        { macro = 'GTK_RC_TOKEN_MODULE_PATH'   , name = "module_path",    nick = "module-path",    value = "301"}, 
        { macro = 'GTK_RC_TOKEN_NORMAL'        , name = "normal",         nick = "normal",         value = "272"}, 
        { macro = 'GTK_RC_TOKEN_PIXMAP_PATH'   , name = "pixmap_path",    nick = "pixmap-path",    value = "287"}, 
        { macro = 'GTK_RC_TOKEN_PRELIGHT'      , name = "prelight",       nick = "prelight",       value = "274"}, 
        { macro = 'GTK_RC_TOKEN_RC'            , name = "rc",             nick = "rc",             value = "298"}, 
        { macro = 'GTK_RC_TOKEN_RTL'           , name = "rtl",            nick = "rtl",            value = "306"}, 
        { macro = 'GTK_RC_TOKEN_SELECTED'      , name = "selected",       nick = "selected",       value = "275"}, 
        { macro = 'GTK_RC_TOKEN_STOCK'         , name = "stock",          nick = "stock",          value = "304"}, 
        { macro = 'GTK_RC_TOKEN_STYLE'         , name = "style",          nick = "style",          value = "288"}, 
        { macro = 'GTK_RC_TOKEN_TEXT'          , name = "text",           nick = "text",           value = "279"}, 
        { macro = 'GTK_RC_TOKEN_THEME'         , name = "theme",          nick = "theme",          value = "297"}, 
        { macro = 'GTK_RC_TOKEN_UNBIND'        , name = "unbind",         nick = "unbind",         value = "308"}, 
        { macro = 'GTK_RC_TOKEN_WIDGET'        , name = "widget",         nick = "widget",         value = "291"}, 
        { macro = 'GTK_RC_TOKEN_WIDGET_CLASS'  , name = "widget_class",   nick = "widget-class",   value = "292"}, 
        { macro = 'GTK_RC_TOKEN_XTHICKNESS'    , name = "xthickness",     nick = "xthickness",     value = "281"}, 
        { macro = 'GTK_RC_TOKEN_YTHICKNESS'    , name = "ythickness",     nick = "ythickness",     value = "282"}, 
    },
    GtkRecentChooserError = {
        { macro = 'GTK_RECENT_CHOOSER_ERROR_INVALID_URI', name = "invalid_uri", nick = "invalid-uri", value = "1"}, 
        { macro = 'GTK_RECENT_CHOOSER_ERROR_NOT_FOUND'  , name = "not_found",   nick = "not-found",   value = "0"}, 
    },
    GtkRecentManagerError = {
        { macro = 'GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING', name = "invalid_encoding", nick = "invalid-encoding", value = "2"}, 
        { macro = 'GTK_RECENT_MANAGER_ERROR_INVALID_URI'     , name = "invalid_uri",      nick = "invalid-uri",      value = "1"}, 
        { macro = 'GTK_RECENT_MANAGER_ERROR_NOT_FOUND'       , name = "not_found",        nick = "not-found",        value = "0"}, 
        { macro = 'GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED'  , name = "not_registered",   nick = "not-registered",   value = "3"}, 
        { macro = 'GTK_RECENT_MANAGER_ERROR_READ'            , name = "read",             nick = "read",             value = "4"}, 
        { macro = 'GTK_RECENT_MANAGER_ERROR_UNKNOWN'         , name = "unknown",          nick = "unknown",          value = "6"}, 
        { macro = 'GTK_RECENT_MANAGER_ERROR_WRITE'           , name = "write",            nick = "write",            value = "5"}, 
    },
    GtkRecentSortType = {
        { macro = 'GTK_RECENT_SORT_CUSTOM', name = "custom", nick = "custom", value = "3"}, 
        { macro = 'GTK_RECENT_SORT_LRU'   , name = "lru",    nick = "lru",    value = "2"}, 
        { macro = 'GTK_RECENT_SORT_MRU'   , name = "mru",    nick = "mru",    value = "1"}, 
        { macro = 'GTK_RECENT_SORT_NONE'  , name = "none",   nick = "none",   value = "0"}, 
    },
    GtkReliefStyle = {
        { macro = 'GTK_RELIEF_HALF'  , name = "half",   nick = "half",   value = "1"}, 
        { macro = 'GTK_RELIEF_NONE'  , name = "none",   nick = "none",   value = "2"}, 
        { macro = 'GTK_RELIEF_NORMAL', name = "normal", nick = "normal", value = "0"}, 
    },
    GtkResizeMode = {
        { macro = 'GTK_RESIZE_IMMEDIATE', name = "immediate", nick = "immediate", value = "2"}, 
        { macro = 'GTK_RESIZE_PARENT'   , name = "parent",    nick = "parent",    value = "0"}, 
        { macro = 'GTK_RESIZE_QUEUE'    , name = "queue",     nick = "queue",     value = "1"}, 
    },
    GtkResponseType = {
        { macro = 'GTK_RESPONSE_ACCEPT'      , name = "accept",       nick = "accept",       value = "-3"}, 
        { macro = 'GTK_RESPONSE_APPLY'       , name = "apply",        nick = "apply",        value = "-10"}, 
        { macro = 'GTK_RESPONSE_CANCEL'      , name = "cancel",       nick = "cancel",       value = "-6"}, 
        { macro = 'GTK_RESPONSE_CLOSE'       , name = "close",        nick = "close",        value = "-7"}, 
        { macro = 'GTK_RESPONSE_DELETE_EVENT', name = "delete_event", nick = "delete-event", value = "-4"}, 
        { macro = 'GTK_RESPONSE_HELP'        , name = "help",         nick = "help",         value = "-11"}, 
        { macro = 'GTK_RESPONSE_NO'          , name = "no",           nick = "no",           value = "-9"}, 
        { macro = 'GTK_RESPONSE_NONE'        , name = "none",         nick = "none",         value = "-1"}, 
        { macro = 'GTK_RESPONSE_OK'          , name = "ok",           nick = "ok",           value = "-5"}, 
        { macro = 'GTK_RESPONSE_REJECT'      , name = "reject",       nick = "reject",       value = "-2"}, 
        { macro = 'GTK_RESPONSE_YES'         , name = "yes",          nick = "yes",          value = "-8"}, 
    },
    GtkRevealerTransitionType = {
        { macro = 'GTK_REVEALER_TRANSITION_TYPE_CROSSFADE'  , name = "crossfade",   nick = "crossfade",   value = "1"}, 
        { macro = 'GTK_REVEALER_TRANSITION_TYPE_NONE'       , name = "none",        nick = "none",        value = "0"}, 
        { macro = 'GTK_REVEALER_TRANSITION_TYPE_SLIDE_DOWN' , name = "slide_down",  nick = "slide-down",  value = "5"}, 
        { macro = 'GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT' , name = "slide_left",  nick = "slide-left",  value = "3"}, 
        { macro = 'GTK_REVEALER_TRANSITION_TYPE_SLIDE_RIGHT', name = "slide_right", nick = "slide-right", value = "2"}, 
        { macro = 'GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP'   , name = "slide_up",    nick = "slide-up",    value = "4"}, 
    },
    GtkScrollStep = {
        { macro = 'GTK_SCROLL_ENDS'            , name = "ends",             nick = "ends",             value = "2"}, 
        { macro = 'GTK_SCROLL_HORIZONTAL_ENDS' , name = "horizontal_ends",  nick = "horizontal-ends",  value = "5"}, 
        { macro = 'GTK_SCROLL_HORIZONTAL_PAGES', name = "horizontal_pages", nick = "horizontal-pages", value = "4"}, 
        { macro = 'GTK_SCROLL_HORIZONTAL_STEPS', name = "horizontal_steps", nick = "horizontal-steps", value = "3"}, 
        { macro = 'GTK_SCROLL_PAGES'           , name = "pages",            nick = "pages",            value = "1"}, 
        { macro = 'GTK_SCROLL_STEPS'           , name = "steps",            nick = "steps",            value = "0"}, 
    },
    GtkScrollType = {
        { macro = 'GTK_SCROLL_END'          , name = "end",           nick = "end",           value = "15"}, 
        { macro = 'GTK_SCROLL_JUMP'         , name = "jump",          nick = "jump",          value = "1"}, 
        { macro = 'GTK_SCROLL_NONE'         , name = "none",          nick = "none",          value = "0"}, 
        { macro = 'GTK_SCROLL_PAGE_BACKWARD', name = "page_backward", nick = "page-backward", value = "4"}, 
        { macro = 'GTK_SCROLL_PAGE_DOWN'    , name = "page_down",     nick = "page-down",     value = "9"}, 
        { macro = 'GTK_SCROLL_PAGE_FORWARD' , name = "page_forward",  nick = "page-forward",  value = "5"}, 
        { macro = 'GTK_SCROLL_PAGE_LEFT'    , name = "page_left",     nick = "page-left",     value = "12"}, 
        { macro = 'GTK_SCROLL_PAGE_RIGHT'   , name = "page_right",    nick = "page-right",    value = "13"}, 
        { macro = 'GTK_SCROLL_PAGE_UP'      , name = "page_up",       nick = "page-up",       value = "8"}, 
        { macro = 'GTK_SCROLL_START'        , name = "start",         nick = "start",         value = "14"}, 
        { macro = 'GTK_SCROLL_STEP_BACKWARD', name = "step_backward", nick = "step-backward", value = "2"}, 
        { macro = 'GTK_SCROLL_STEP_DOWN'    , name = "step_down",     nick = "step-down",     value = "7"}, 
        { macro = 'GTK_SCROLL_STEP_FORWARD' , name = "step_forward",  nick = "step-forward",  value = "3"}, 
        { macro = 'GTK_SCROLL_STEP_LEFT'    , name = "step_left",     nick = "step-left",     value = "10"}, 
        { macro = 'GTK_SCROLL_STEP_RIGHT'   , name = "step_right",    nick = "step-right",    value = "11"}, 
        { macro = 'GTK_SCROLL_STEP_UP'      , name = "step_up",       nick = "step-up",       value = "6"}, 
    },
    GtkScrollablePolicy = {
        { macro = 'GTK_SCROLL_MINIMUM', name = "minimum", nick = "minimum", value = "0"}, 
        { macro = 'GTK_SCROLL_NATURAL', name = "natural", nick = "natural", value = "1"}, 
    },
    GtkSelectionMode = {
        { macro = 'GTK_SELECTION_BROWSE'  , name = "browse",   nick = "browse",   value = "2"}, 
        { macro = 'GTK_SELECTION_MULTIPLE', name = "multiple", nick = "multiple", value = "3"}, 
        { macro = 'GTK_SELECTION_NONE'    , name = "none",     nick = "none",     value = "0"}, 
        { macro = 'GTK_SELECTION_SINGLE'  , name = "single",   nick = "single",   value = "1"}, 
    },
    GtkSensitivityType = {
        { macro = 'GTK_SENSITIVITY_AUTO', name = "auto", nick = "auto", value = "0"}, 
        { macro = 'GTK_SENSITIVITY_OFF' , name = "off",  nick = "off",  value = "2"}, 
        { macro = 'GTK_SENSITIVITY_ON'  , name = "on",   nick = "on",   value = "1"}, 
    },
    GtkShadowType = {
        { macro = 'GTK_SHADOW_ETCHED_IN' , name = "etched_in",  nick = "etched-in",  value = "3"}, 
        { macro = 'GTK_SHADOW_ETCHED_OUT', name = "etched_out", nick = "etched-out", value = "4"}, 
        { macro = 'GTK_SHADOW_IN'        , name = "in",         nick = "in",         value = "1"}, 
        { macro = 'GTK_SHADOW_NONE'      , name = "none",       nick = "none",       value = "0"}, 
        { macro = 'GTK_SHADOW_OUT'       , name = "out",        nick = "out",        value = "2"}, 
    },
    GtkShortcutType = {
        { macro = 'GTK_SHORTCUT_ACCELERATOR'                    , name = "accelerator",                     nick = "accelerator",                     value = "0"}, 
        { macro = 'GTK_SHORTCUT_GESTURE'                        , name = "gesture",                         nick = "gesture",                         value = "7"}, 
        { macro = 'GTK_SHORTCUT_GESTURE_PINCH'                  , name = "gesture_pinch",                   nick = "gesture-pinch",                   value = "1"}, 
        { macro = 'GTK_SHORTCUT_GESTURE_ROTATE_CLOCKWISE'       , name = "gesture_rotate_clockwise",        nick = "gesture-rotate-clockwise",        value = "3"}, 
        { macro = 'GTK_SHORTCUT_GESTURE_ROTATE_COUNTERCLOCKWISE', name = "gesture_rotate_counterclockwise", nick = "gesture-rotate-counterclockwise", value = "4"}, 
        { macro = 'GTK_SHORTCUT_GESTURE_STRETCH'                , name = "gesture_stretch",                 nick = "gesture-stretch",                 value = "2"}, 
        { macro = 'GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_LEFT'  , name = "gesture_two_finger_swipe_left",   nick = "gesture-two-finger-swipe-left",   value = "5"}, 
        { macro = 'GTK_SHORTCUT_GESTURE_TWO_FINGER_SWIPE_RIGHT' , name = "gesture_two_finger_swipe_right",  nick = "gesture-two-finger-swipe-right",  value = "6"}, 
    },
    GtkSizeGroupMode = {
        { macro = 'GTK_SIZE_GROUP_BOTH'      , name = "both",       nick = "both",       value = "3"}, 
        { macro = 'GTK_SIZE_GROUP_HORIZONTAL', name = "horizontal", nick = "horizontal", value = "1"}, 
        { macro = 'GTK_SIZE_GROUP_NONE'      , name = "none",       nick = "none",       value = "0"}, 
        { macro = 'GTK_SIZE_GROUP_VERTICAL'  , name = "vertical",   nick = "vertical",   value = "2"}, 
    },
    GtkSizeRequestMode = {
        { macro = 'GTK_SIZE_REQUEST_CONSTANT_SIZE'   , name = "constant_size",    nick = "constant-size",    value = "2"}, 
        { macro = 'GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH', name = "height_for_width", nick = "height-for-width", value = "0"}, 
        { macro = 'GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT', name = "width_for_height", nick = "width-for-height", value = "1"}, 
    },
    GtkSortType = {
        { macro = 'GTK_SORT_ASCENDING' , name = "ascending",  nick = "ascending",  value = "0"}, 
        { macro = 'GTK_SORT_DESCENDING', name = "descending", nick = "descending", value = "1"}, 
    },
    GtkSpinButtonUpdatePolicy = {
        { macro = 'GTK_UPDATE_ALWAYS'  , name = "always",   nick = "always",   value = "0"}, 
        { macro = 'GTK_UPDATE_IF_VALID', name = "if_valid", nick = "if-valid", value = "1"}, 
    },
    GtkSpinType = {
        { macro = 'GTK_SPIN_END'          , name = "end",           nick = "end",           value = "5"}, 
        { macro = 'GTK_SPIN_HOME'         , name = "home",          nick = "home",          value = "4"}, 
        { macro = 'GTK_SPIN_PAGE_BACKWARD', name = "page_backward", nick = "page-backward", value = "3"}, 
        { macro = 'GTK_SPIN_PAGE_FORWARD' , name = "page_forward",  nick = "page-forward",  value = "2"}, 
        { macro = 'GTK_SPIN_STEP_BACKWARD', name = "step_backward", nick = "step-backward", value = "1"}, 
        { macro = 'GTK_SPIN_STEP_FORWARD' , name = "step_forward",  nick = "step-forward",  value = "0"}, 
        { macro = 'GTK_SPIN_USER_DEFINED' , name = "user_defined",  nick = "user-defined",  value = "6"}, 
    },
    GtkStackTransitionType = {
        { macro = 'GTK_STACK_TRANSITION_TYPE_CROSSFADE'       , name = "crossfade",        nick = "crossfade",        value = "1"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_NONE'            , name = "none",             nick = "none",             value = "0"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_OVER_DOWN'       , name = "over_down",        nick = "over-down",        value = "9"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_OVER_DOWN_UP'    , name = "over_down_up",     nick = "over-down-up",     value = "17"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_OVER_LEFT'       , name = "over_left",        nick = "over-left",        value = "10"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_OVER_LEFT_RIGHT' , name = "over_left_right",  nick = "over-left-right",  value = "18"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_OVER_RIGHT'      , name = "over_right",       nick = "over-right",       value = "11"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_OVER_RIGHT_LEFT' , name = "over_right_left",  nick = "over-right-left",  value = "19"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_OVER_UP'         , name = "over_up",          nick = "over-up",          value = "8"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_OVER_UP_DOWN'    , name = "over_up_down",     nick = "over-up-down",     value = "16"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_SLIDE_DOWN'      , name = "slide_down",       nick = "slide-down",       value = "5"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT'      , name = "slide_left",       nick = "slide-left",       value = "3"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT', name = "slide_left_right", nick = "slide-left-right", value = "6"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_SLIDE_RIGHT'     , name = "slide_right",      nick = "slide-right",      value = "2"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_SLIDE_UP'        , name = "slide_up",         nick = "slide-up",         value = "4"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN'   , name = "slide_up_down",    nick = "slide-up-down",    value = "7"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_UNDER_DOWN'      , name = "under_down",       nick = "under-down",       value = "13"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_UNDER_LEFT'      , name = "under_left",       nick = "under-left",       value = "14"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_UNDER_RIGHT'     , name = "under_right",      nick = "under-right",      value = "15"}, 
        { macro = 'GTK_STACK_TRANSITION_TYPE_UNDER_UP'        , name = "under_up",         nick = "under-up",         value = "12"}, 
    },
    GtkStateType = {
        { macro = 'GTK_STATE_ACTIVE'      , name = "active",       nick = "active",       value = "1"}, 
        { macro = 'GTK_STATE_FOCUSED'     , name = "focused",      nick = "focused",      value = "6"}, 
        { macro = 'GTK_STATE_INCONSISTENT', name = "inconsistent", nick = "inconsistent", value = "5"}, 
        { macro = 'GTK_STATE_INSENSITIVE' , name = "insensitive",  nick = "insensitive",  value = "4"}, 
        { macro = 'GTK_STATE_NORMAL'      , name = "normal",       nick = "normal",       value = "0"}, 
        { macro = 'GTK_STATE_PRELIGHT'    , name = "prelight",     nick = "prelight",     value = "2"}, 
        { macro = 'GTK_STATE_SELECTED'    , name = "selected",     nick = "selected",     value = "3"}, 
    },
    GtkTextBufferTargetInfo = {
        { macro = 'GTK_TEXT_BUFFER_TARGET_INFO_BUFFER_CONTENTS', name = "buffer_contents", nick = "buffer-contents", value = "-1"}, 
        { macro = 'GTK_TEXT_BUFFER_TARGET_INFO_RICH_TEXT'      , name = "rich_text",       nick = "rich-text",       value = "-2"}, 
        { macro = 'GTK_TEXT_BUFFER_TARGET_INFO_TEXT'           , name = "text",            nick = "text",            value = "-3"}, 
    },
    GtkTextDirection = {
        { macro = 'GTK_TEXT_DIR_LTR' , name = "ltr",  nick = "ltr",  value = "1"}, 
        { macro = 'GTK_TEXT_DIR_NONE', name = "none", nick = "none", value = "0"}, 
        { macro = 'GTK_TEXT_DIR_RTL' , name = "rtl",  nick = "rtl",  value = "2"}, 
    },
    GtkTextExtendSelection = {
        { macro = 'GTK_TEXT_EXTEND_SELECTION_LINE', name = "line", nick = "line", value = "1"}, 
        { macro = 'GTK_TEXT_EXTEND_SELECTION_WORD', name = "word", nick = "word", value = "0"}, 
    },
    GtkTextViewLayer = {
        { macro = 'GTK_TEXT_VIEW_LAYER_ABOVE'     , name = "above",      nick = "above",      value = "1"}, 
        { macro = 'GTK_TEXT_VIEW_LAYER_ABOVE_TEXT', name = "above_text", nick = "above-text", value = "3"}, 
        { macro = 'GTK_TEXT_VIEW_LAYER_BELOW'     , name = "below",      nick = "below",      value = "0"}, 
        { macro = 'GTK_TEXT_VIEW_LAYER_BELOW_TEXT', name = "below_text", nick = "below-text", value = "2"}, 
    },
    GtkTextWindowType = {
        { macro = 'GTK_TEXT_WINDOW_BOTTOM' , name = "bottom",  nick = "bottom",  value = "6"}, 
        { macro = 'GTK_TEXT_WINDOW_LEFT'   , name = "left",    nick = "left",    value = "3"}, 
        { macro = 'GTK_TEXT_WINDOW_PRIVATE', name = "private", nick = "private", value = "0"}, 
        { macro = 'GTK_TEXT_WINDOW_RIGHT'  , name = "right",   nick = "right",   value = "4"}, 
        { macro = 'GTK_TEXT_WINDOW_TEXT'   , name = "text",    nick = "text",    value = "2"}, 
        { macro = 'GTK_TEXT_WINDOW_TOP'    , name = "top",     nick = "top",     value = "5"}, 
        { macro = 'GTK_TEXT_WINDOW_WIDGET' , name = "widget",  nick = "widget",  value = "1"}, 
    },
    GtkToolbarSpaceStyle = {
        { macro = 'GTK_TOOLBAR_SPACE_EMPTY', name = "empty", nick = "empty", value = "0"}, 
        { macro = 'GTK_TOOLBAR_SPACE_LINE' , name = "line",  nick = "line",  value = "1"}, 
    },
    GtkToolbarStyle = {
        { macro = 'GTK_TOOLBAR_BOTH'      , name = "both",       nick = "both",       value = "2"}, 
        { macro = 'GTK_TOOLBAR_BOTH_HORIZ', name = "both_horiz", nick = "both-horiz", value = "3"}, 
        { macro = 'GTK_TOOLBAR_ICONS'     , name = "icons",      nick = "icons",      value = "0"}, 
        { macro = 'GTK_TOOLBAR_TEXT'      , name = "text",       nick = "text",       value = "1"}, 
    },
    GtkTreeViewColumnSizing = {
        { macro = 'GTK_TREE_VIEW_COLUMN_AUTOSIZE' , name = "autosize",  nick = "autosize",  value = "1"}, 
        { macro = 'GTK_TREE_VIEW_COLUMN_FIXED'    , name = "fixed",     nick = "fixed",     value = "2"}, 
        { macro = 'GTK_TREE_VIEW_COLUMN_GROW_ONLY', name = "grow_only", nick = "grow-only", value = "0"}, 
    },
    GtkTreeViewDropPosition = {
        { macro = 'GTK_TREE_VIEW_DROP_AFTER'         , name = "after",          nick = "after",          value = "1"}, 
        { macro = 'GTK_TREE_VIEW_DROP_BEFORE'        , name = "before",         nick = "before",         value = "0"}, 
        { macro = 'GTK_TREE_VIEW_DROP_INTO_OR_AFTER' , name = "into_or_after",  nick = "into-or-after",  value = "3"}, 
        { macro = 'GTK_TREE_VIEW_DROP_INTO_OR_BEFORE', name = "into_or_before", nick = "into-or-before", value = "2"}, 
    },
    GtkTreeViewGridLines = {
        { macro = 'GTK_TREE_VIEW_GRID_LINES_BOTH'      , name = "both",       nick = "both",       value = "3"}, 
        { macro = 'GTK_TREE_VIEW_GRID_LINES_HORIZONTAL', name = "horizontal", nick = "horizontal", value = "1"}, 
        { macro = 'GTK_TREE_VIEW_GRID_LINES_NONE'      , name = "none",       nick = "none",       value = "0"}, 
        { macro = 'GTK_TREE_VIEW_GRID_LINES_VERTICAL'  , name = "vertical",   nick = "vertical",   value = "2"}, 
    },
    GtkUnit = {
        { macro = 'GTK_UNIT_INCH'  , name = "inch",   nick = "inch",   value = "2"}, 
        { macro = 'GTK_UNIT_MM'    , name = "mm",     nick = "mm",     value = "3"}, 
        { macro = 'GTK_UNIT_NONE'  , name = "none",   nick = "none",   value = "0"}, 
        { macro = 'GTK_UNIT_POINTS', name = "points", nick = "points", value = "1"}, 
    },
    GtkWidgetHelpType = {
        { macro = 'GTK_WIDGET_HELP_TOOLTIP'   , name = "tooltip",    nick = "tooltip",    value = "0"}, 
        { macro = 'GTK_WIDGET_HELP_WHATS_THIS', name = "whats_this", nick = "whats-this", value = "1"}, 
    },
    GtkWindowPosition = {
        { macro = 'GTK_WIN_POS_CENTER'          , name = "center",           nick = "center",           value = "1"}, 
        { macro = 'GTK_WIN_POS_CENTER_ALWAYS'   , name = "center_always",    nick = "center-always",    value = "3"}, 
        { macro = 'GTK_WIN_POS_CENTER_ON_PARENT', name = "center_on_parent", nick = "center-on-parent", value = "4"}, 
        { macro = 'GTK_WIN_POS_MOUSE'           , name = "mouse",            nick = "mouse",            value = "2"}, 
        { macro = 'GTK_WIN_POS_NONE'            , name = "none",             nick = "none",             value = "0"}, 
    },
    GtkWindowType = {
        { macro = 'GTK_WINDOW_POPUP'   , name = "popup",    nick = "popup",    value = "1"}, 
        { macro = 'GTK_WINDOW_TOPLEVEL', name = "toplevel", nick = "toplevel", value = "0"}, 
    },
    GtkWrapMode = {
        { macro = 'GTK_WRAP_CHAR'     , name = "char",      nick = "char",      value = "1"}, 
        { macro = 'GTK_WRAP_NONE'     , name = "none",      nick = "none",      value = "0"}, 
        { macro = 'GTK_WRAP_WORD'     , name = "word",      nick = "word",      value = "2"}, 
        { macro = 'GTK_WRAP_WORD_CHAR', name = "word_char", nick = "word-char", value = "3"}, 
    },
}); end;
----  [Gtk Enumerates] End ... 


---------------- gtk3.24.patch.lua，控件大致按照字母顺序（除个别存在前置依赖关系）

---------------------  GtkPageSetupUnixDialog
Gtk324.GtkPageSetupUnixDialog = {
  class = "GtkPageSetupUnixDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_page_setup_unix_dialog_new((const gchar*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}))", 
            params = { type = {"const gchar*", "GtkWindow*"}, 
                       name = {"title", "parent"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkDialog,
  implement = {Gtk324.GtkBuildable}, 
  -- 还需要依赖其他的特殊模块
  ext_modules = {"gtk+-unix-print-3.0"},
  -- 此模块依赖的外部头文件
  ext_inc_files = {"gtk/gtkunixprint.h"},
};

---------------------  GtkPrintUnixDialog
Gtk324.GtkPrintUnixDialog = {
  class = "GtkPrintUnixDialog", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_print_unix_dialog_new((const gchar*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}))", 
            params = { type = {"const gchar*", "GtkWindow*"}, 
                       name = {"title", "parent"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = { 
    -- 属性名称  属性类型 缺省值 代码生成
  },
  parent = Gtk324.GtkDialog,
  implement = {Gtk324.GtkBuildable}, 
  -- 还需要依赖其他的特殊模块
  ext_modules = {"gtk+-unix-print-3.0"},
  -- 此模块依赖的外部头文件
  ext_inc_files = {"gtk/gtkunixprint.h"}, 
};

function Gtk324.table_copy_table_in_patch(ori_tab)
  if (type(ori_tab) ~= "table") then
      return nil, 0
  end
  local new_tab = {}
  local max_index = 1
  for i,v in pairs(ori_tab) do
      local vtyp = type(v)
      if (vtyp == "table") then
          new_tab[i] = Gtk324.table_copy_table_in_patch(v)
      elseif (vtyp == "thread") then
          new_tab[i] = v
      elseif (vtyp == "userdata") then
          new_tab[i] = v
      else
          new_tab[i] = v
      end
  max_index = max_index + 1
  end
  return new_tab, max_index
end

-- 往表中插入多条记录
function Gtk324.insert_more(tbl, ...)
    local args = { ... }
    for _, item in ipairs(args) do
        table.insert(tbl, item);
    end
end;

-- 往表中插入多条记录
function Gtk324.copy_and_insert_more(tbl, ...)
  local args = { ... }
  local new_tbl = table.pack(table.unpack(tbl))
  -- 删除新表中的n字段
  new_tbl.n = nil;
  for _, item in ipairs(args) do
    table.insert(new_tbl, item);
  end
  return new_tbl;
end;

-- 对于某些特定的类，需要一个统一补丁函数，生成g_object_set的生成代码
function Gtk324.PatchGlibProperty(class, property_list)
  local function string_starts(String,Start)
      return string.sub(String,1,string.len(Start))==Start
  end
  local function string_ends(String,End)
      return End=='' or string.sub(String,-string.len(End))==End
  end
  local function item_is_in_table(name, tbl)
    for _, item in ipairs(tbl) do
        if name == item then
            return true
        end
    end
    return false
  end
  -- 传入类实例，直接进行Patch操作
  if class.property ~= nil then
      -- 优化一下传入property_list时的处理方式
      local check_property_list = class.property;
      -- 如果不为空，则可以做一个临时的小对象
      if property_list ~= nil and type(property_list) == "table" then
          check_property_list = {}
          for _, prop_name in ipairs(property_list) do
              if class.property[prop_name] == nil then
                  print("[ERROR] PatchGlibProperty fail, missing " .. prop_name " in " .. class.class)
              else
                check_property_list[prop_name] = class.property[prop_name]
              end
          end
      end
      for prop_name, property in pairs(check_property_list) do
          -- 跳过特殊字段
          if (not string_starts(prop_name, "__")) or (not string_ends(prop_name, "__")) then
              local real_prop_name = string.gsub(prop_name, "_", "-")
              -- 如果是处理全部属性，或者 指定了需要处理的属性
              if property_list == nil or item_is_in_table(prop_name, property_list) or item_is_in_table(real_prop_name, property_list) then
                    -- 如果生成代码为空，且rwflags为空或者为可读写rw
                    if property.__gencode__ == nil and (property.rwflags == nil or property.rwflags == "rw" or property.rwflags == "w") then
                        property.__gencode__ = {"g_object_set(G_OBJECT ({* id *}), \"" ..  real_prop_name .. "\", (".. property.__type__ .. ")({* property.value *}), NULL)"}
                    end
            end
          end
      end
  end
end

----------------==  GtkActionable
----------------==  GtkActivatable
----------------==  GtkAppChooser
----------------==  GtkBuildable
----------------==  GtkCellAccessibleParent
----------------==  GtkCellEditable
----------------==  GtkCellLayout
----------------==  GtkColorChooser
----------------==  GtkEditable
----------------==  GtkFileChooser

----------------==  GtkFontChooser
----------------==  GtkOrientable
----------------==  GtkPrintOperationPreview
----------------==  GtkRecentChooser
Gtk324.PatchGlibProperty(Gtk324.GtkRecentChooser, {"recent-manager"});

----------------==  GtkScrollable
Gtk324.GtkScrollable.property.hadjustment.__default__ = "NULL";
Gtk324.GtkScrollable.property.vadjustment.__default__ = "NULL";

----------------==  GtkStyleProvider
----------------==  GtkToolShell
----------------==  GtkTreeDragDest
----------------==  GtkTreeDragSource
----------------==  GtkTreeModel
----------------==  GtkTreeSortable


----------------==  GtkAccelGroup
----------------==  GtkAccelMap
----------------==  GtkAccessible
----------------==  GtkAction
-- GtkAction的构建以name为关键字，其label、tooltip、stock_id三个属性属于可选
Gtk324.GtkAction.property["name"]["__construct__"] = 1
Gtk324.GtkAction.property["label"]["__construct__"] = 1
Gtk324.GtkAction.property["tooltip"]["__construct__"] = 1
Gtk324.GtkAction.property["stock-id"]["__construct__"] = 1
Gtk324.PatchGlibProperty(Gtk324.GtkAction, {"hide-if-empty", "visible-overflown"});

----------------==  GtkActionGroup
Gtk324.GtkActionGroup.child_property = {
    -- 属性名称  属性类型 缺省值
    key       = {__type__="gchar*"          ,__default__ = "F1"               , macro_code = {uisources = "ADD_ACCEL_TO_ACTION_GROUP"}},
    modifiers = {__type__="GdkModifierType" ,__default__ = "GDK_CONTROL_MASK" },
    label     = {__type__="gchar*"},
};

--[[
  类中的packing数据规则说明：
    1、packing表（数组格式）的每个子项都是一个表，顺序存放，判断需要哪些packing_build时，会先取得当前实例数据中所有的packing属性数据字段名称（name列表）
    2、packing子项(字典格式)中，group字段是一个数组，其中存放属性名，仅当当前实例packing属性数据中全部包含相应的属性名，才命中此子项条目
    3、命中条目后，会将子项的group_code（数组格式）依次拷贝packing_build用于输出代码，同时删除group_code中每个子项的name列表、filter_out列表
    4、删除后的name列表如果不为空，会继续下一packing子项的匹配，如果子项结束，但当前类存在父类，则递归继续匹配，直到全部匹配结束、或者父类为空
    5、生成代码时，packing_build列表内容是group_code子项的合并项，列表中每个子项都会进行处理并生成代码，每个packing_build子项结构与group_code子项结构完全一致
    6、packing_build子项在生成代码时会判断name字段中对应packing属性是否存在，如果不存在，则需要取得默认值，以供gen_code使用。
    7、如果name中的字段，有一项在packing属性中不存在，同时当前子项存在can_skip字段，则会跳过此条目的代码生成
]]--
Gtk324.GtkActionGroup["packing"] = {
    {
        -- 用于判断是否属于当前组
        group = {"key", "modifiers"}, group_code = { { name = {"key", "modifiers"},  
            gen_code = "ADD_ACCEL_TO_ACTION_GROUP((GtkActionGroup*){* id *}, (GtkAction*){* child.id.value *}, {* packing.key.value *}, (GdkModifierType)({* packing.modifiers.value *}))"},
        },
    },
    {
        -- 用于判断是否属于当前组
        group = {},group_code = { { name = {},  
            gen_code = "gtk_action_group_add_action((GtkActionGroup*){* id *}, (GtkAction*){* child.id.value *})"},
        },
    },
};

----------------==  GtkAdjustment
----------------==  GtkApplication
Gtk324.PatchGlibProperty(Gtk324.GtkApplication, {"register-session"});

----------------==  GtkBuilder
----------------==  GtkCellArea
----------------==  GtkCellAreaContext
----------------==  GtkCellRenderer
Gtk324.GtkCellRenderer.property["__group__"] = {
  {
      -- 用于判断是否属于当前组
      group = {"xalign", "yalign"},
      -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
      group_code = {
          {name = {"xalign", "yalign"}, gen_code = "gtk_cell_renderer_set_alignment((GtkCellRenderer*){* id *}, (gfloat){* this.xalign.value *}, (gfloat){* this.yalign.value *})" },
      }
  },
  {
      -- 用于判断是否属于当前组
      group = {"xpad", "ypad"},
      -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
      group_code = {
          {name = {"xpad", "ypad"}, gen_code = "gtk_cell_renderer_set_padding((GtkCellRenderer*){* id *}, (gint){* this.xpad.value *}, (gint){* this.ypad.value *})" },
      }
  },
  {
    -- 用于判断是否属于当前组
    group = {"height", "width"},
    -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
    group_code = {
        {name = {"height", "width"}, gen_code = "gtk_cell_renderer_set_fixed_size((GtkCellRenderer*){* id *}, (gint){* this.height.value *}, (gint){* this.width.value *})" },
    }
  }
};

function Gtk324.PatchGtkCellRenderers(class)
    local function string_starts(String,Start)
        return string.sub(String,1,string.len(Start))==Start
    end
    local function string_ends(String,End)
        return End=='' or string.sub(String,-string.len(End))==End
    end
    -- 传入类实例，直接进行Patch操作
    if class.property ~= nil then
        for prop_name, property in pairs(class.property) do
            -- 跳过特殊字段
            if (not string_starts(prop_name, "__")) or (not string_ends(prop_name, "__")) then
                local real_prop_name = string.gsub(prop_name, "_", "-")
                -- 如果生成代码为空
                if property.__gencode__ == nil then
                    property.__gencode__ = {"g_object_set(G_OBJECT ({* id *}), \"" .. 
                                              real_prop_name .. "\", (".. property.__type__ .. ")({* property.value *}), NULL)"}
                end
            end
        end
    end
end

----------------==  GtkClipboard
----------------==  GtkCssProvider
----------------==  GtkEntryBuffer
Gtk324.GtkEntryBuffer.constructor.new.gencode = "gtk_entry_buffer_new((const gchar*)(NULL), (gint)(0))";
Gtk324.GtkEntryBuffer.property.text.__gencode__ = {"gtk_entry_buffer_set_text((GtkEntryBuffer*)({* id *}), (const gchar*)({* property.value *}), -1)"}

----------------==  GtkEntryCompletion
Gtk324.GtkEntryCompletion.constructor.new_with_area = { gencode = "gtk_entry_completion_new_with_area((GtkCellArea*)({* this.['cell-area'].value *}))", 
                                                        params = { type = {"GtkCellArea*"}, name = {"cell-area"} } }
Gtk324.PatchGlibProperty(Gtk324.GtkEntryCompletion, {"cell-area"});

----------------==  GtkEntryIconAccessible
----------------==  GtkEventController
Gtk324.PatchGlibProperty(Gtk324.GtkEventController, {"widget"});

----------------==  GtkFileFilter
----------------==  GtkIMContext
Gtk324.PatchGlibProperty(Gtk324.GtkIMContext, {"input-hints", "input-purpose"});

----------------==  GtkIconFactory
Gtk324.GtkIconFactory.child_property = {
    -- 属性名称  属性类型 缺省值
    stock_id    = {__type__="gchar*"},
};
Gtk324.GtkIconFactory.packing = {
    {
        -- 用于判断是否属于当前组
        group = {"stock_id"},
        group_code = {
            { name = {"stock_id"},  gen_code = "gtk_icon_factory_add((GtkIconFactory*){* id *}, (const gchar*){* packing['stock_id'].value *}, (GtkIconSet*){* child.id.value *})"},
            { name = {"stock_id"},  gen_code = "gtk_icon_set_unref((GtkIconSet*){* child.id.value *})"},
        },
    },
};
Gtk324.GtkIconSet = {
  class = "GtkIconSet",
  constructor = {
    -- 名称[- ==> _],
    new = { gencode = "gtk_icon_set_new()",
            params = { type = {}, name = {} } },
  },
  signal = {
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = {
    -- 属性名称  属性类型 缺省值 代码生成
  },
  packing = {
      {
        -- 用于判断是否属于当前组
          group = {},
          group_code = {
              { name = {},  gen_code = "gtk_icon_set_add_source((GtkIconSet*){* id *}, (GtkIconSource*){* child.id.value *})"},
              { name = {},  gen_code = "gtk_icon_source_free((GtkIconSource*){* child.id.value *})"},
          },
      },
  },
  parent = nil,
};
Gtk324.GtkIconSource = {
  class = "GtkIconSource",
  constructor = {
    -- 名称[- ==> _],
    new = { gencode = "gtk_icon_source_new()",
            params = { type = {}, name = {} } },
  },
  signal = {
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = {
    -- 属性名称  属性类型 缺省值 代码生成
    filename   = {__type__="gchar*"           ,__default__ = "NULL",  __gencode__ = {"gtk_icon_source_set_filename((GtkIconSource*)({* id *}), (const gchar*)({* property.value *}))"} },
    icon_name  = {__type__="gchar*"           ,__default__ = "NULL",  __gencode__ = {"gtk_icon_source_set_icon_name((GtkIconSource*)({* id *}), (const gchar*)({* property.value *}))"} },
    size       = {__type__="GtkIconSize"      ,__default__ = "-1" ,   __gencode__ = {"gtk_icon_source_set_size((GtkIconSource*)({* id *}), (GtkIconSize)({* property.value *}))"} },
    direction  = {__type__="GtkTextDirection" ,__default__ = "-1" ,   __gencode__ = {"gtk_icon_source_set_direction((GtkIconSource*)({* id *}), (GtkTextDirection)({* property.value *}))"} },
    state      = {__type__="GtkStateType"     ,__default__ = "-1" ,   __gencode__ = {"gtk_icon_source_set_state((GtkIconSource*)({* id *}), (GtkStateType)({* property.value *}))"} },
  },
  parent = nil,
};

----------------==  GtkIconInfo
----------------==  GtkIconTheme
----------------==  GtkListStore
-- GtkListStore的第一个属性是column_0，然后是column_1，column_2，...，最后以column_count结尾
-- 这里利用了生成属性代码中使用Gtkui.pairs对属性进行了排序的特性
Gtk324.GtkListStore.property["column_0"] = {__type__="gint" ,__default__ = "0",
                      __gencode__ = {"static GType __{*id*}_gtypes__[{* property.value *} + 1] = { //"}}; -- 末尾添加双斜杠，用于注释;代码
Gtk324.GtkListStore.property["^column_%d+$"] = {__type__="GType*", regex = true,
                               __gencode__ = {"    {* Gtkui.GlibBaseTypeToGType(property.value) *}, //"}}; -- 末尾添加双斜杠，用于注释;代码
Gtk324.GtkListStore.property["column_count"] = {__type__="gint" ,__default__ = "0",
                      __gencode__ = {"G_TYPE_INT}",
                                    "gtk_list_store_set_column_types((GtkListStore*){* id *}, (gint){* property.value *}, __{*id*}_gtypes__)"}};

--- 生成GtkListStore的data属性代码
Gtk324.GtkListStore.property["^data_%d+_######$"] = {__type__="gint", regex = true,
                      __gencode__ = {"{ //",
                                    "    GtkTreeIter iter",
                                    "    gtk_list_store_append ((GtkListStore*){* id *}, &iter)",
                                    "    gtk_list_store_set ((GtkListStore*){* id *}, &iter, //"}}; -- 末尾添加双斜杠，用于注释;代码
Gtk324.GtkListStore.property["^data_%d+_%d+$"] = {__type__="GType*", regex = true,
                      __gencode__ = {"        {* Gtkui.GlibBaseTypeToGType(property.type) *}, {* property.value *}, //"}}; -- 末尾添加双斜杠，用于注释;代码
Gtk324.GtkListStore.property["^data_%d+_======$"] = {__type__="gint", regex = true,
                      __gencode__ = {"    -1)", "}"}};

-- GtkListStore的构建函数
Gtk324.GtkListStore.constructor["new"] = { gencode = "gtk_list_store_new((gint)1, G_TYPE_INT)", params = { type = {}, name = {} } };
--GtkListStore.constructor["new"] = { gencode = "gtk_list_store_new((gint)({* this.n_columns.value *}), {% for idx=1,this.n_columns.value do %}G_TYPE_INT, {% end %} G_TYPE_INT)",
--                                        params = { type = {"gint"}, name = {"n_columns"} } };
Gtk324.GtkListStore.constructor["newv"] = nil;

----------------==  GtkMountOperation
----------------==  GtkNativeDialog
----------------==  GtkNotebookPageAccessible
----------------==  GtkNumerableIcon
Gtk324.GtkNumerableIcon.property["background-icon"].__gencode__ = {"gtk_numerable_icon_set_background_gicon((GtkNumerableIcon*)({* id *}), (const GIcon*)({* property.value *}))"};

----------------==  GtkPageSetup
----------------==  GtkPrintContext
----------------==  GtkPrintOperation
----------------==  GtkPrintSettings
----------------==  GtkRcStyle
----------------==  GtkRecentFilter
----------------==  GtkRecentManager
----------------==  GtkSettings
----------------==  GtkSizeGroup
----- top_widget存储相应根控件，widget_%d存储子控件，所有子控件必须在根控件中
Gtk324.GtkSizeGroup.property["top_widget"] = {__type__="GtkWidget*", __gencode__ = {""}, macro_code = {uisources = "GTK_SIZE_GROUP_LOOKUP"}};
Gtk324.GtkSizeGroup.property["^widget_%d+$"] = {__type__="GtkWidget*", regex = true, ext_depend = true,
                __gencode__ = {"gtk_size_group_add_widget((GtkSizeGroup*){* id *}, (GtkWidget*)GTK_SIZE_GROUP_LOOKUP({* this.top_widget.value *}, {* property.value *}))"}};
Gtk324.GtkSizeGroup.property["widget_count"] = {__type__="guint", __gencode__ = {""}};

----------------==  GtkStatusIcon
Gtk324.GtkStatusIcon.constructor.new_from_file = { gencode = "gtk_status_icon_new_from_file((const gchar*)({* this.file.value *}))",
                                                  params = { type = {"gchar*"}, name = {"file"} } };
Gtk324.GtkStatusIcon.constructor.new_from_gicon = { gencode = "gtk_status_icon_new_from_gicon((GIcon*)({* this.gicon.value *}))",
                                                  params = { type = {"GIcon*"}, name = {"gicon"} } };
Gtk324.GtkStatusIcon.constructor.new_from_stock = { gencode = "gtk_status_icon_new_from_stock((const gchar*)({* this.stock.value *}))",
                                                  params = { type = {"gchar*"}, name = {"stock"} } };
                                                  
----------------==  GtkStyle
----------------==  GtkStyleContext
----------------==  GtkStyleProperties
----------------==  GtkTextBuffer
-- 需要patch GtkTextBuffer["constructor"]的new
Gtk324.GtkTextBuffer.constructor["new"] = { gencode = "gtk_text_buffer_new((GtkTextTagTable*)({* this['tag-table'].value *}))",
                                        params = { type = {"GtkTextTagTable*"}, name = {"tag-table"} } };
-- 需要patch GtkTextBuffer_property的tag_table
Gtk324.GtkTextBuffer.property["tag-table"]["__default__"] = "NULL"
Gtk324.GtkTextBuffer.property["tag-table"]["__construct__"] = 1
-- 需要patch GtkTextBuffer_property的text
Gtk324.GtkTextBuffer.property["text"]["__gencode__"] = {'gtk_text_buffer_set_text((GtkTextBuffer*){* id *}, (const gchar*){* property.value *}, (gint)-1);'}

----------------==  GtkTextChildAnchor
----------------==  GtkTextMark
----------------==  GtkTextTag
Gtk324.PatchGlibProperty(Gtk324.GtkTextTag);

----------------==  GtkTextTagTable
Gtk324.GtkTextTagTable.packing = {
    {
      -- 用于判断是否属于当前组
        group = {}, group_code = { { name = {},  
            gen_code = "gtk_text_tag_table_add((GtkTextTagTable*){* id *}, (GtkTextTag*){* child.id.value *})"},
        },
    },
};

----------------==  GtkThemingEngine
----------------==  GtkTooltip
----------------==  GtkToplevelAccessible
----------------==  GtkTreeModelFilter
Gtk324.GtkTreeModelFilter.constructor = {
    -- 名称[- ==> _],
    new = { gencode = "gtk_tree_model_filter_new((GtkTreeModel*)({* this['child-model'].value *}), (GtkTreePath*)({* this['virtual-root'].value *}))",
            params = { type = {"GtkTreeModel*", "GtkTreePath*"}, name = {"child-model", "virtual-root"} } },
};
Gtk324.GtkTreeModelFilter.property["child-model"].is_top_widget = true;
Gtk324.GtkTreeModelFilter.property["child-model"].macro_code = {uisources = "TOP_WIDGET"};
Gtk324.GtkTreeModelFilter.property["virtual-root"].__default__ = "NULL";

----------------==  GtkTreeModelSort
Gtk324.GtkTreeModelSort.constructor = {
    -- 名称[- ==> _],
    new = { gencode = "gtk_tree_model_sort_new_with_model((GtkTreeModel*)({* this.model.value *}) )",
            params = { type = {"GtkTreeModel*"}, name = {"model"} } },
};

----------------==  GtkTreeSelection
Gtk324.GtkTreeSelection.constructor = {     -- 名称[- ==> _],
    new = { gencode = "gtk_tree_view_get_selection((GtkTreeView*) {* parent.property.id.value *})",
            params = { type = {}, name = {} } },
};

----------------==  GtkTreeStore
-- GtkTreeStore的第一个属性是column_0，然后是column_1，column_2，...，最后以column_count结尾
-- 这里利用了生成属性代码中使用Gtkui.pairs对属性进行了排序的特性
Gtk324.GtkTreeStore.property["column_0"] = {__type__="gint" ,__default__ = "0",
                      __gencode__ = {"static GType __{*id*}_gtypes__[{* property.value *} + 1] = { //"}}; -- 末尾添加双斜杠，用于注释;代码
Gtk324.GtkTreeStore.property["^column_%d+$"] = {__type__="GType*", regex = true,
                      __gencode__ = {"    {* Gtkui.GlibBaseTypeToGType(property.value) *}, //"}}; -- 末尾添加双斜杠，用于注释;代码
Gtk324.GtkTreeStore.property["column_count"] = {__type__="gint" ,__default__ = "0",
                      __gencode__ = {"G_TYPE_INT}",
                                     "gtk_tree_store_set_column_types((GtkTreeStore*){* id *}, (gint){* property.value *}, __{*id*}_gtypes__)"}};
-- GtkTreeStore的构建函数
--GtkTreeStore.constructor["new"] = { gencode = "gtk_tree_store_new((gint)({* this.n_columns.value *}),{% for idx=1,this.n_columns.value do %}G_TYPE_INT, {% end %} G_TYPE_INT)",
--                                       params = { type = {"gint"}, name = {"n_columns"} } };
Gtk324.GtkTreeStore.constructor["new"] = { gencode = "gtk_tree_store_new((gint)(1), G_TYPE_INT)",
                                       params = { type = {}, name = {} } };
Gtk324.GtkTreeStore.constructor["newv"] = nil;

----------------==  GtkTreeViewColumn
-- ，需要删除new_with_attributes构造函数，分步构造
Gtk324.GtkTreeViewColumn.constructor.new_with_attributes = nil;
Gtk324.GtkTreeViewColumn.constructor.new_with_area = nil;

-- 添加一个expand的子属性
Gtk324.GtkTreeViewColumn.child_property = {expand = {__type__="gboolean" ,__default__ = "FALSE" }};
Gtk324.GtkTreeViewColumn["packing"] = {
  {
      -- 用于判断是否属于当前组
      group = {}, group_code = { { name = {"expand"},  
          gen_code = "gtk_tree_view_column_pack_start((GtkTreeViewColumn*){* id *}, (GtkCellRenderer*){* child.id.value *}, {* packing.expand.value *})"},
      },
  },
};

----------------==  GtkUIManager
Gtk324.GtkUIManager.child_property = { 
    -- 属性名称  属性类型 缺省值
    ui        = {__type__="gboolean"},
    parent_id = {__type__="GtkUIManager*"},
};
Gtk324.GtkUIManager.packing = {
    {
        group = {"ui"}, group_code = { { name = {"ui"},  
        gen_code = "gtk_ui_manager_add_ui_from_string((GtkUIManager*){* id *}, (const gchar*){* child.id.value *}, -1, NULL)"},},
    },
    {
        group = {}, group_code = { { name = {},
        gen_code = "gtk_ui_manager_insert_action_group((GtkUIManager*){* id *}, ({* child.class.value *}*){* child.id.value *}, 0)"},},
    },
};
Gtk324.GtkUIManagerChildUI = {
    class = "GtkUIManagerChildUI", 
    constructor = { 
      -- 名称[- ==> _], 
      new = { gencode = "{* this.merge_id.value *}", params = { type = {"gchar*"}, name = {"merge_id"} } },
    },
    signal = { 
      -- 信号名称[- ==> _], 信号返回值, 信号参数列表
    },
    property = { 
      -- 属性名称  属性类型 缺省值 代码生成
      merge_id = {__type__="gchar*", macro_code = {uiheaders = "GTK_UI_MANAGER_CHILD_UI_DEFINE"}},
    },
    parent = nil,
};

----------------==  GtkWidget
Gtk324.GtkWidget.property["__group__"] = {
    {
        -- 用于判断是否属于当前组
        group = {"width-request", "height-request"},
        -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
        group_code = {
            {name = {"width-request", "height-request"}, gen_code = "gtk_widget_set_size_request((GtkWidget*){* id *}, {* this['width-request'].value *}, {* this['height-request'].value *})" },
        }
    },
};

-- 部分子控件，如GtkMessageDialog之类需要parent参数
Gtk324.GtkWidget.property["parent"]["__default__"] = "NULL"

-- GtkWidget的has_default属性对应的代码生成函数
Gtk324.GtkWidget.property["has-default"]["__gencode__"] = {"({* property.value *}) ? gtk_widget_grab_default((GtkWidget*)({* id *})) : (void)0"};
Gtk324.GtkWidget.property["has-focus"]["__gencode__"] = {"({* property.value *}) ? gtk_widget_grab_focus((GtkWidget*)({* id *})) : (void)0"};
Gtk324.GtkWidget.property["is-focus"]["__gencode__"] = {"({* property.value *}) ? gtk_widget_grab_focus((GtkWidget*)({* id *})) : (void)0"};

Gtk324.PatchGlibProperty(Gtk324.GtkWidget, {"margin"});

----------------==  GtkWindowGroup
----------------==  GtkCalendar
----------------==  GtkCellAccessible
----------------==  GtkCellAreaBox
----------------==  GtkCellRendererPixbuf
----------------==  GtkCellRendererProgress
----------------==  GtkCellRendererSpinner
----------------==  GtkCellRendererText
----------------==  GtkCellRendererToggle
----------------==  GtkCellView
-- 这个属性允许为NULL，对应宏名为GET_GDK_COLOR2
Gtk324.GtkCellView.property["background"]["__gencode__"] = {"gtk_cell_view_set_background_color((GtkCellView*)({* id *}, (const GdkColor*)({* property.value *}))"};
Gtk324.GtkCellView.property["background-gdk"]["__gencode__"] = {"gtk_cell_view_set_background_color((GtkCellView*)({* id *}, (const GdkColor*)({* property.value *}))"};
Gtk324.PatchGlibProperty(Gtk324.GtkCellView, {"background-set"});

----------------==  GtkContainer
-- GtkContainer的child property属性生成代码
Gtk324.GtkContainer["packing"] = {
    {
        -- 用于判断是否属于当前组
        group = {}, group_code = { { name = {}, 
            gen_code = "gtk_container_add((GtkContainer*){* id *}, (GtkWidget*){* child.id.value *})"}
        },
    },
};

----------------==  GtkDrawingArea
----------------==  GtkEntry
-- GtkEntry的构造函数
Gtk324.GtkEntry.constructor["new_with_max_length"] = {  gencode = "gtk_entry_new_with_max_length((gint)({* this['max-length'].value *}))",
													params = { type = {"gint"}, name = {"max-length"} } };

-- GtkEntry的属性
Gtk324.GtkEntry.property["invisible-char"]["__type__"]                = "gunichar";
--Gtk324.GtkEntry.property["editable"]["__gencode__"]              = {"g_object_set((GObject*){* id *}, \"editable\", (gboolean){* property.value *}, NULL)"};
Gtk324.GtkEntry.property["xalign"]["__gencode__"]                = {"gtk_entry_set_alignment((GtkEntry*){* id *}, (gfloat){* property.value *})"};
--Gtk324.GtkEntry.property["caps-lock-warning"]["__gencode__"]     = {"g_object_set((GObject*){* id *}, \"caps-lock-warning\", (gboolean){* property.value *}, NULL)"};
Gtk324.GtkEntry.property["cursor-position"]["__gencode__"]       = {"gtk_editable_set_position((GtkEditable*){* id *}, (gint){* property.value *})"};
--Gtk324.GtkEntry.property["invisible-char-set"]["__gencode__"]    = {"g_object_set((GObject*){* id *}, \"invisible-char-set\", (gboolean){* property.value *}, NULL)"};
Gtk324.GtkEntry.property["primary-icon-activatable"]["__gencode__"]         =  {"gtk_entry_set_icon_activatable((GtkEntry*){* id *}, GTK_ENTRY_ICON_PRIMARY, (gboolean){* property.value *})"};
Gtk324.GtkEntry.property["primary-icon-gicon"]["__gencode__"]               =  {"gtk_entry_set_icon_from_gicon((GtkEntry*){* id *}, GTK_ENTRY_ICON_PRIMARY, (GIcon*){* property.value *})"};
Gtk324.GtkEntry.property["primary-icon-name"]["__gencode__"]                =  {"gtk_entry_set_icon_from_icon_name((GtkEntry*){* id *}, GTK_ENTRY_ICON_PRIMARY, (const gchar*){* property.value *})"};
Gtk324.GtkEntry.property["primary-icon-pixbuf"]["__gencode__"]              =  {"gtk_entry_set_icon_from_pixbuf((GtkEntry*){* id *}, GTK_ENTRY_ICON_PRIMARY, (GdkPixbuf*){* property.value *})"};
Gtk324.GtkEntry.property["primary-icon-sensitive"]["__gencode__"]           =  {"gtk_entry_set_icon_sensitive((GtkEntry*){* id *}, GTK_ENTRY_ICON_PRIMARY, (gboolean){* property.value *})"};
Gtk324.GtkEntry.property["primary-icon-stock"]["__gencode__"]               =  {"gtk_entry_set_icon_from_stock((GtkEntry*){* id *}, GTK_ENTRY_ICON_PRIMARY, (const gchar*){* property.value *})"};
Gtk324.GtkEntry.property["primary-icon-tooltip-markup"]["__gencode__"]      =  {"gtk_entry_set_icon_tooltip_markup((GtkEntry*){* id *}, GTK_ENTRY_ICON_PRIMARY, (const gchar*){* property.value *})"};
Gtk324.GtkEntry.property["primary-icon-tooltip-text"]["__gencode__"]        =  {"gtk_entry_set_icon_tooltip_text((GtkEntry*){* id *}, GTK_ENTRY_ICON_PRIMARY, (const gchar*){* property.value *})"};
Gtk324.GtkEntry.property["secondary-icon-activatable"]["__gencode__"]       =  {"gtk_entry_set_icon_activatable((GtkEntry*){* id *}, GTK_ENTRY_ICON_SECONDARY, (gboolean){* property.value *})"};
Gtk324.GtkEntry.property["secondary-icon-gicon"]["__gencode__"]             =  {"gtk_entry_set_icon_from_gicon((GtkEntry*){* id *}, GTK_ENTRY_ICON_SECONDARY, (GIcon*){* property.value *})"};
Gtk324.GtkEntry.property["secondary-icon-name"]["__gencode__"]              =  {"gtk_entry_set_icon_from_icon_name((GtkEntry*){* id *}, GTK_ENTRY_ICON_SECONDARY, (const gchar*){* property.value *})"};
Gtk324.GtkEntry.property["secondary-icon-pixbuf"]["__gencode__"]            =  {"gtk_entry_set_icon_from_pixbuf((GtkEntry*){* id *}, GTK_ENTRY_ICON_SECONDARY, (GdkPixbuf*){* property.value *})"};
Gtk324.GtkEntry.property["secondary-icon-sensitive"]["__gencode__"]         =  {"gtk_entry_set_icon_sensitive((GtkEntry*){* id *}, GTK_ENTRY_ICON_SECONDARY, (gboolean){* property.value *})"};
Gtk324.GtkEntry.property["secondary-icon-stock"]["__gencode__"]             =  {"gtk_entry_set_icon_from_stock((GtkEntry*){* id *}, GTK_ENTRY_ICON_SECONDARY, (const gchar*){* property.value *})"};
Gtk324.GtkEntry.property["secondary-icon-tooltip-markup"]["__gencode__"]    =  {"gtk_entry_set_icon_tooltip_markup((GtkEntry*){* id *}, GTK_ENTRY_ICON_SECONDARY, (const gchar*){* property.value *})"};
Gtk324.GtkEntry.property["secondary-icon-tooltip-text"]["__gencode__"]      =  {"gtk_entry_set_icon_tooltip_text((GtkEntry*){* id *}, GTK_ENTRY_ICON_SECONDARY, (const gchar*){* property.value *})"};
--Gtk324.GtkEntry.property["truncate-multiline"]["__gencode__"]               =  {"g_object_set((GObject*){* id *}, \"truncate-multiline\", (gboolean){* property.value *}, NULL)"};
Gtk324.PatchGlibProperty(Gtk324.GtkEntry, {"editable", "caps-lock-warning", "invisible-char-set", "shadow-type", "truncate-multiline"});

----------------==  GtkEventControllerKey
----------------==  GtkEventControllerMotion
----------------==  GtkEventControllerScroll
----------------==  GtkFileChooserNative
----------------==  GtkGLArea
----------------==  GtkGesture
----------------==  GtkHSV
----------------==  GtkIMContextSimple
----------------==  GtkIMMulticontext
----------------==  GtkInvisible
----------------==  GtkLevelBar
----------------==  GtkMisc

-- GtkMisc的组合属性
Gtk324.GtkMisc.property["__group__"] = {
    {
        -- 用于判断是否属于当前组
        group = {"xalign", "yalign"},
        -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
        group_code = {
            {name = {"xalign", "yalign"}, gen_code = "gtk_misc_set_alignment((GtkMisc*){* id *}, (gfloat){* this.xalign.value *}, (gfloat){* this.yalign.value *})" },
        }
    },
    {
        -- 用于判断是否属于当前组
        group = {"xpad", "ypad"},
        -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
        group_code = {
            {name = {"xpad", "ypad"}, gen_code = "gtk_misc_set_padding((GtkMisc*){* id *}, (gint){* this.xpad.value *}, (gint){* this.ypad.value *})" },
        }
    },
};

----------------==  GtkPadController
----------------==  GtkProgressBar

----------------==  GtkRange
Gtk324.GtkRange.property.adjustment.__default__ = "NULL";

----------------==  GtkRecentAction
Gtk324.GtkRecentAction.constructor.new_for_manager = nil;

----------------==  GtkSeparator
----------------==  GtkSpinner
Gtk324.PatchGlibProperty(Gtk324.GtkSpinner, {"active"});

----------------==  GtkSwitch
----------------==  GtkToggleAction
----------------==  GtkWidgetAccessible
----------------==  GtkArrow
-- GtkArrow的arrow_type、shadow_type属性属于必选
Gtk324.GtkArrow.property["arrow-type"]["__construct__"] = 1
Gtk324.GtkArrow.property["shadow-type"]["__construct__"] = 1

----------------==  GtkArrowAccessible
----------------==  GtkBin
----------------==  GtkBox
-- GtkBox的child property属性生成代码
Gtk324.GtkBox["packing"] = {
    {
      -- 用于判断是否属于当前组，默认pack_type为gtk_box_pack_start，当有pack_type时，通常就是gtk_box_pack_end
      group = {"pack_type"}, group_code = {
          { name = {"expand", "fill", "padding", "pack_type"}, filter_out = {"position"}, 
            gen_code = "gtk_box_pack_end((GtkBox*){* id *}, (GtkWidget*){* child.id.value *}, {* packing.expand.value *}, {* packing.fill.value *}, {* packing.padding.value *})"}
      },
    }, 
    {
      -- 全空的名称，则永远都会匹配到
      group = {}, group_code = {
          { name = {"expand", "fill", "padding"}, filter_out = {"position"}, 
            gen_code = "gtk_box_pack_start((GtkBox*){* id *}, (GtkWidget*){* child.id.value *}, {* packing.expand.value *}, {* packing.fill.value *}, {* packing.padding.value *})"},
          -- 一般也不需要配置position
          --{ name = {"position"}, 
          --  gen_code = "gtk_box_reorder_child((GtkBox*)gtk_dialog_get_action_area((GtkDialog*){* id *}, (GtkWidget*){* child.id.value *}, {* packing.position.value *})"}
      },
    },
};

----------------==  GtkCellRendererAccel
----------------==  GtkCellRendererCombo
----------------==  GtkCellRendererSpin

Gtk324.PatchGtkCellRenderers(Gtk324.GtkCellRenderer);
Gtk324.PatchGtkCellRenderers(Gtk324.GtkCellRendererAccel);
Gtk324.PatchGtkCellRenderers(Gtk324.GtkCellRendererCombo);
Gtk324.PatchGtkCellRenderers(Gtk324.GtkCellRendererPixbuf);
Gtk324.PatchGtkCellRenderers(Gtk324.GtkCellRendererProgress);
Gtk324.PatchGtkCellRenderers(Gtk324.GtkCellRendererSpinner);
Gtk324.PatchGtkCellRenderers(Gtk324.GtkCellRendererText);
Gtk324.PatchGtkCellRenderers(Gtk324.GtkCellRendererToggle);
Gtk324.PatchGtkCellRenderers(Gtk324.GtkCellRendererSpin);
-- 打完补丁后，这个函数就不需要了
Gtk324.PatchGtkCellRenderers = nil;

----------------==  GtkContainerAccessible
----------------==  GtkContainerCellAccessible
----------------==  GtkEntryAccessible
----------------==  GtkFixed
-- GtkFixed的child property属性生成代码
Gtk324.GtkFixed["packing"] = {
    {
        -- 用于判断是否属于当前组
        -- 正常情况下，都会有x与y的，除非x、y = 0
        group = {}, group_code = { { name = {"x", "y"}, 
            gen_code = "gtk_fixed_put((GtkFixed*){* id *}, (GtkWidget*){* child.id.value *}, {* packing.x.value *}, {* packing.y.value *})"}
        },
    },
};

----------------==  GtkFlowBox
----------------==  GtkGestureRotate
----------------==  GtkGestureSingle
----------------==  GtkGestureZoom
----------------==  GtkGrid
-- GtkGrid的child property属性生成代码
Gtk324.GtkGrid["packing"] = {
  {
      -- 用于判断是否属于当前组
      group = {}, group_code = { { name = {"left-attach", "top-attach", "width", "height"},
          gen_code = "gtk_grid_attach((GtkGrid*){* id *}, (GtkWidget*){* child.id.value *}, {* packing['left-attach'].value *}, {* packing['top-attach'].value *}, {* packing['width'].value *}, {* packing['height'].value *})"},
      }
  },
};

----------------==  GtkHSeparator
----------------==  GtkHeaderBar
----------------==  GtkIconView
----------------==  GtkImage
-- GtkImage的构建函数，需要全部重新打patch
Gtk324.GtkImage.constructor = {
    -- 名称[- ==> _]，
    new                = {  gencode = "gtk_image_new()",
                            params = { type = {}, name = {} } },
    new_from_animation = {  gencode = "gtk_image_new_from_animation((GdkPixbufAnimation*)({* this['pixbuf-animation'].value *}))",
                            params = { type = {"GdkPixbufAnimation*"}, name = {"pixbuf-animation"} } },
    new_from_file_utf8 = { gencode = "gtk_image_new_from_file_utf8((GdkPixbufAnimation*)({* this.file.value *}))",
                            params = { type = {"gchar*"}, name = {"file"} } },
    new_from_gicon     = { gencode = "gtk_image_new_from_gicon((GIcon*)({* this.gicon.value *}), (GtkIconSize)({* this['icon-size'].value *}))",
                            params = { type = {"GIcon*", "gint"}, name = {"gicon", "icon-size"} } },
    new_from_icon_name = { gencode = "gtk_image_new_from_gicon((GIcon*)({* this['icon-name'].value *}), (GtkIconSize)({* this['icon-size'].value *}))",
                            params = { type = {"const gchar*", "gint"}, name = {"icon-name", "icon-size"} } },
    new_from_icon_set  = { gencode = "gtk_image_new_from_icon_set((GtkIconSet*)({* this['icon-set'].value *}), (GtkIconSize)({* this['icon-size'].value *}))",
                            params = { type = {"GtkIconSet*", "gint"}, name = {"icon-set", "icon-size"} } },
    new_from_image     = { gencode = "gtk_image_new_from_image((GdkImage*)({* this.image.value *}), (GdkBitmap*)({* this.mask.value *}))",
                            params = { type = {"GdkImage*", "GdkBitmap*"}, name = {"image", "mask"} } },
    new_from_stock     = { gencode = "gtk_image_new_from_stock((const gchar*)({* this.stock.value *}), (GtkIconSize)({* this['icon-size'].value *}))",
                            params = { type = {"gchar*", "gint"}, name = {"stock", "icon-size"} } },
    new_from_pixbuf    = { gencode = "gtk_image_new_from_pixbuf((GdkPixbuf*)GET_GDK_PIX_BUF({* this.pixbuf.value *}))", 
                            params = { type = {"GdkPixbuf*"}, name = {"pixbuf"} } },
};

-- GtkImage的属性设置接口
Gtk324.GtkImage.property["gicon"]["__need_more__"] = {"icon-size"};       -- 需要额外的属性，如果不存在，则应该去取得默认值
Gtk324.GtkImage.property["icon-name"]["__need_more__"] = {"icon-size"};   -- 需要额外的属性，如果不存在，则应该去取得默认值
Gtk324.GtkImage.property["icon-set"]["__need_more__"] = {"icon-size"};    -- 需要额外的属性，如果不存在，则应该去取得默认值
Gtk324.GtkImage.property["stock"]["__need_more__"] = {"icon-size"};       -- 需要额外的属性，如果不存在，则应该去取得默认值
Gtk324.GtkImage.property["gicon"]["__gencode__"]     = {"gtk_image_set_from_gicon((GtkImage*)({* id *}), (GIcon*)({* property.value *}), (GtkIconSize)({* this[\"icon-size\"].value *}))"};
Gtk324.GtkImage.property["icon-name"]["__gencode__"] = {"gtk_image_set_from_icon_name((GtkImage*)({* id *}), (const gchar*)({* property.value *}), (GtkIconSize)({* this[\"icon-size\"].value *}))"};
Gtk324.GtkImage.property["icon-set"]["__gencode__"]  = {"gtk_image_set_from_icon_set((GtkImage*)({* id *}), (GtkIconSet*)({* property.value *}), (GtkIconSize)({* this[\"icon-size\"].value *}))"};
Gtk324.GtkImage.property["stock"]["__gencode__"]     = {"gtk_image_set_from_stock((GtkImage*){* id *}, (gchar*){* property.value *}, (GtkIconSize){* this[\"icon-size\"].value *})"};

Gtk324.GtkImage.property["pixbuf-animation"]["__gencode__"]    = {"gtk_image_set_from_animation((GtkImage*)({* id *}), (GdkPixbufAnimation*)({* property.value *}))"};
Gtk324.PatchGlibProperty(Gtk324.GtkImage, {"use-fallback"});

----------------==  GtkImageAccessible
----------------==  GtkLabel
-- GtkLabel的构建函数
Gtk324.GtkLabel.constructor["new"]                = { gencode = "gtk_label_new((const gchar*)({* this.label.value *}))",
                                                    params = { type = {"gchar*"}, name = {"label"} } };
Gtk324.GtkLabel.constructor["new_with_mnemonic"]  = { gencode = "gtk_label_new_with_mnemonic((const gchar*)({* this.label.value *}))",
                                                    params = { type = {"gchar*", "gboolean"}, name = {"label", "use-underline"} } };

Gtk324.GtkLabel.property.wrap["__gencode__"] = {"gtk_label_set_line_wrap((GtkLabel*)({* id *}), (gboolean)({* property.value *}))"}
Gtk324.GtkLabel.property['wrap-mode']["__gencode__"] = {"gtk_label_set_line_wrap_mode((GtkLabel*)({* id *}), (PangoWrapMode)({* property.value *}))"}

-- GtkLabel的第一个Pango属性是pango_attr_0_start，然后是pango_attr_XXX 最后以pango_attr_z_end结尾
-- 这里利用了生成属性代码中使用Gtkui.pairs对属性进行了排序的特性
Gtk324.GtkLabel.property["pango_attr_0_start"] = {__type__="gint" ,__default__ = "0",
                      __gencode__ = {"{ //",
                                     "    PangoAttribute* _{* id *}_pango_attr = NULL",
                                     "    PangoAttrList*  _{* id *}_pango_attr_list = pango_attr_list_new()"}
};
Gtk324.GtkLabel.property["^pango_attr_[%-%l]+_1_start$"] = {__type__="guint", __default__ = "0", regex = true,
                      __gencode__ = {"    _{* id *}_pango_attr->start_index = {* property.value *}"}
};
Gtk324.GtkLabel.property["^pango_attr_[%-%l]+_2_end$"] = {__type__="guint", __default__ = "4294967295", regex = true,
                      __gencode__ = {"    _{* id *}_pango_attr->end_index = {* property.value *}"}
};
Gtk324.GtkLabel.property["^pango_attr_[%-%l]+_3_value$"] = {__type__="guint", regex = true,
                      __gencode__ = {"    pango_attr_list_insert (_{* id *}_pango_attr_list, _{* id *}_pango_attr)"}
};

Gtk324.GtkLabel.property["pango_attr_language_0_value"] = {__type__="gchar*",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_language_new((PangoLanguage)(pango_language_from_string({* property.value *})))",}
};
Gtk324.GtkLabel.property["pango_attr_style_0_value"] = {__type__="PangoStyle",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_style_new((PangoStyle)({* property.value *}))"}
};
Gtk324.GtkLabel.property["pango_attr_weight_0_value"] = {__type__="PangoWeight",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_weight_new((PangoWeight)({* property.value *}))"}
};
Gtk324.GtkLabel.property["pango_attr_variant_0_value"] = {__type__="PangoVariant",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_variant_new((PangoVariant)({* property.value *}))"}
};
Gtk324.GtkLabel.property["pango_attr_stretch_0_value"] = {__type__="PangoStretch",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_stretch_new((PangoStretch)({* property.value *}))"}
};
Gtk324.GtkLabel.property["pango_attr_underline_0_value"] = {__type__="gboolean",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_underline_new((PangoUnderline)({* property.value *}))"}
};
Gtk324.GtkLabel.property["pango_attr_strikethrough_0_value"] = {__type__="gboolean",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_strikethrough_new((gboolean)({* property.value *}))"}
};
Gtk324.GtkLabel.property["pango_attr_gravity_0_value"] = {__type__="PangoGravity",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_gravity_new((PangoGravity)({* property.value *}))"}
};
Gtk324.GtkLabel.property["pango_attr_gravity-hint_0_value"] = {__type__="PangoGravityHint",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_gravity_hint_new((PangoGravityHint)({* property.value *}))"}
};
Gtk324.GtkLabel.property["pango_attr_family_0_value"] = {__type__="gchar*",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_family_new((const gchar*)({* property.value *}))"}
};
Gtk324.GtkLabel.property["pango_attr_size_0_value"] = {__type__="gint",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_size_new({* property.value *})"}
};
Gtk324.GtkLabel.property["pango_attr_absolute-size_0_value"] = {__type__="gint",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_size_new_absolute({* property.value *})"}
};
Gtk324.GtkLabel.property["pango_attr_font_desc_0_value"] = {__type__="gchar*",
                      __gencode__ = {"    { //","        PangoFontDesc* _font_desc = pango_font_description_from_string({* property.value *})",
                                     "        _{* id *}_pango_attr = pango_attr_font_desc_new(_font_desc)",
                                     "        pango_font_description_free(_font_desc)","    } //"}
};
Gtk324.GtkLabel.property["pango_attr_foreground_0_value"] = {__type__="gchar*", macro_code = {uisources = "GDK_COLOR"},
                      __gencode__ = {"    { // ","        const GdkColor* color = GET_GDK_COLOR({* property.value *})",
                                     "        _{* id *}_pango_attr = pango_attr_foreground_new(color->red, color->green, color->blue)","    } //"}
};
Gtk324.GtkLabel.property["pango_attr_background_0_value"] = {__type__="gchar*", macro_code = {uisources = "GDK_COLOR"},
                      __gencode__ = {"    { // ", "        const GdkColor* color = GET_GDK_COLOR({* property.value *})",
                                     "        _{* id *}_pango_attr = pango_attr_background_new(color->red, color->green, color->blue)", "    } //"}
};
Gtk324.GtkLabel.property["pango_attr_underline-color_0_value"] = {__type__="gchar*", macro_code = {uisources = "GDK_COLOR"},
                      __gencode__ = {"    { // ", "        const GdkColor* color = GET_GDK_COLOR({* property.value *})",
                                     "        _{* id *}_pango_attr = pango_attr_underline_color_new(color->red, color->green, color->blue)", "    } //"}
};
Gtk324.GtkLabel.property["pango_attr_strikethrough-color_0_value"] = {__type__="gchar*", macro_code = {uisources = "GDK_COLOR"},
                      __gencode__ = {"    { // ", "        const GdkColor* color = GET_GDK_COLOR({* property.value *})",
                                     "        _{* id *}_pango_attr = pango_attr_strikethrough_color_new(color->red, color->green, color->blue)", "    } //"}
};
Gtk324.GtkLabel.property["pango_attr_scale_0_value"] = {__type__="gdouble",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_scale_new((gdouble)({* property.value *}))"}
};
Gtk324.GtkLabel.property["pango_attr_letter_spacing_0_value"] = {__type__="gint",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_letter_spacing_new({* property.value *})"}
};
Gtk324.GtkLabel.property["pango_attr_rise_0_value"] = {__type__="gint",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_rise_new({* property.value *})"}
};
Gtk324.GtkLabel.property["pango_attr_fallback_0_value"] = {__type__="gboolean",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_fallback_new((gboolean)({* property.value *}))"}
};
Gtk324.GtkLabel.property["pango_attr_font_features_0_value"] = {__type__="gchar*",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_font_features_new({* property.value *})"}
};
Gtk324.GtkLabel.property["pango_attr_foreground_alpha_0_value"] = {__type__="gint",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_foreground_alpha_new({* property.value *})"}
};
Gtk324.GtkLabel.property["pango_attr_background_alpha_0_value"] = {__type__="gint",
                      __gencode__ = {"    _{* id *}_pango_attr = pango_attr_background_alpha_new({* property.value *})"}
};
Gtk324.GtkLabel.property["pango_attr_z_end"] = {__type__="gint" ,__default__ = "0",
                      __gencode__ = {"    gtk_label_set_attributes((GtkLabel*)({* id *}), (PangoAttrList*)(_{* id *}_pango_attr_list))",
                                     "    pango_attr_list_unref(_{* id *}_pango_attr_list)", "} //"}
};


----------------==  GtkLabelAccessible
----------------==  GtkLayout
-- GtkLayout的child property属性生成代码
Gtk324.GtkLayout["packing"] = {
    {
        -- 用于判断是否属于当前组
        -- 正常情况下，都会有x与y的，除非x、y = 0
        group = {},  group_code = { {name = {"x", "y"}, 
            gen_code = "gtk_layout_put((GtkLayout*){* id *}, (GtkWidget*){* child.id.value *}, {* packing.x.value *}, {* packing.y.value *})"}},
    },
};

-- GtkLayout的property属性生成代码
Gtk324.GtkLayout.property["__group__"] = {
    {
        -- 用于判断是否属于当前组
        group = {"height", "width"},
        -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
        group_code = {
            {name = {"height", "width"}, gen_code = "gtk_layout_set_size((GtkWidget*){* id *}, {* this.width.value *}, {* this.height.value *})" },
        }
    },
};

----------------==  GtkLevelBarAccessible
----------------==  GtkListBox
----------------==  GtkMenuShell
Gtk324.GtkMenuShell["packing"] = {
    {
        -- 用于判断是否属于当前组
        group = {},  group_code = { {name = {}, 
            gen_code = "gtk_menu_shell_append((GtkMenuShell*){* id *}, (GtkWidget*){* child.id.value *})"}},
    },
};

----------------==  GtkNotebook
-- GtkNotebook的child property属性生成代码，根据child property属性来判断调用哪一句话生成代码
Gtk324.GtkNotebook["packing"] = {
    {
        -- 用于判断是否属于当前组
        group = {}, group_code = { { name = {}, can_skip = true, gen_code = "" , 
            filter_out = {"detachable", "menu-label", "position", "reorderable", "tab-expand", "tab-fill", "tab-pack", "tab-label"}}},
    },
};
Gtk324.GtkNotebook.property['enable-popup'].__gencode__ = {"g_object_set((GObject*){* id *}, \"enable-popup\", (gboolean){* property.value *}, NULL)"};
--Gtk324.GtkNotebook.property.homogeneous.__gencode__ = {"gtk_notebook_set_homogeneous_tabs((GtkNotebook*)({* id *}), (gboolean)({* property.value *}))";};

---------------------  GtkNotebookLabel，包装用于处理GtkNotebook的处理
Gtk324.GtkNotebookLabel = {
    class = "GtkNotebookLabel",
    -- 直接套用GtkLabel的构造函数
    constructor = Gtk324.GtkLabel.constructor,
    signal = {
        -- 信号名称[- ==> _]， 信号返回值, 信号参数列表
    },
    property = {
    },
    -- 直接拷贝GtkNotebook的子属性
    child_property = Gtk324.table_copy_table_in_patch(Gtk324.GtkNotebook.child_property),
    packing = {
        { group = {"parent_id"}, group_code = { { name = {"parent_id"},                     
              gen_code = "gtk_notebook_append_page((GtkNotebook*){* packing.parent_id.value *}, (GtkWidget*){* child.id.value *}, (GtkWidget*){* id *})"}}
        },
        { group = {"detachable"}, group_code = { { name = {"detachable"}, 
              gen_code = "gtk_notebook_set_tab_detachable((GtkNotebook*){* packing.parent_id.value *}, (GtkWidget*){* child.id.value *}, {* packing.detachable.value *})"}}
        },
        { group = {"menu-label"}, group_code = { { name = {"menu-label"}, 
            gen_code = "gtk_notebook_set_menu_label_text((GtkNotebook*){* packing.parent_id.value *}, (GtkWidget*){* child.id.value *}, {* packing[\"menu-label\"].value *})"}}
        },
        { group = {"position"}, group_code = { { name = {"position"}, can_skip = true, gen_code = ""}}
        },
        { group = {"reorderable"}, group_code = { { name = {"reorderable"}, 
            gen_code = "gtk_notebook_set_tab_reorderable((GtkNotebook*){* packing.parent_id.value *}, (GtkWidget*){* child.id.value *}, {* packing.reorderable.value *})"}}
        },
        { group = {}, group_code = { { name = {"tab-expand", "tab-fill", "tab-pack"}, can_skip = true,
            gen_code = "gtk_notebook_set_tab_label_packing((GtkNotebook*){* packing.parent_id.value *}, (GtkWidget*){* child.id.value *}, {* packing[\"tab_expand\"].value *}, {* packing[\"tab_fill\"].value *}, {* packing[\"tab_pack\"].value *})"}}
        },
        { group = {"tab-label"}, group_code = { { name = {"tab-label"}, 
            gen_code = "gtk_notebook_set_tab_label_text((GtkNotebook*){* packing.parent_id.value *}, (GtkWidget*){* child.id.value *}, (const gchar *)({* packing[\"tab_label\"].value *})"}}
        },
    },
    parent = Gtk324.GtkLabel,
};

-- 添加一个子属性，TODO
Gtk324.GtkNotebookLabel.child_property.parent_id = {__type__="GtkNotebook*", __default__ = "NULL", macro_code = {uiheaders = "NOTEBOOK_LABEL_DEFINE"}};

----------------==  GtkPaned
-- GtkPaned的child property属性生成代码，根据child property属性来判断调用哪一句话生成代码
Gtk324.GtkPaned["packing"] = {
    {
        -- 用于判断是否属于当前组
        group = {}, group_code = { { name = {"resize", "shrink"}, 
            gen_code = "(*((NULL == gtk_paned_get_child1((GtkPaned*){* id *})) ? &gtk_paned_pack1: &gtk_paned_pack2))((GtkPaned*){* id *}, (GtkWidget*){* child.id.value *}, {* packing.resize.value *}, {* packing.shrink.value *})"}
        },
    },
};
Gtk324.PatchGlibProperty(Gtk324.GtkPaned, {"position-set"});

----------------==  GtkProgressBarAccessible
----------------==  GtkRadioAction
Gtk324.GtkRadioAction.property.group.__gencode__ = {"gtk_radio_action_set_group((GtkRadioAction*)({* id *}), (GSList*)gtk_radio_action_get_group({* property.value *}))"};
Gtk324.GtkRadioAction.property.value["__gencode__"] = {"gtk_radio_action_set_current_value((GtkRadioAction*)({* id *}), (gint){* property.value *})"};

----------------==  GtkRangeAccessible
----------------==  GtkRendererCellAccessible
----------------==  GtkScale
Gtk324.GtkScale.constructor.new_with_range = nil;

----------------==  GtkScrollbar
----------------==  GtkSearchEntry
----------------==  GtkSocket
----------------==  GtkSpinButton
Gtk324.GtkSpinButton.constructor.new2 = {
    gencode = "gtk_spin_button_new((GtkAdjustment*)(NULL), (gdouble)(0), (guint)(0))", 
    params = { type = {}, name = {} }
};

Gtk324.GtkSpinButton.constructor.new_with_range = { 
    gencode = "gtk_spin_button_new_with_range((gdouble)gtk_adjustment_get_lower({* this.adjustment.value *}), (gdouble)gtk_adjustment_get_upper({* this.adjustment.value *}), (gdouble)gtk_adjustment_get_step_increment({* this.adjustment.value *}))", 
    params = { type = {"GtkAdjustment*"}, name = {"adjustment"}}
};

-- 默认adjustment属性为NULL
Gtk324.GtkSpinButton.property["adjustment"]["__default__"] = "NULL";
Gtk324.PatchGlibProperty(Gtk324.GtkSpinButton, {"climb-rate"});

----------------==  GtkSpinnerAccessible
----------------==  GtkStack
----------------==  GtkSwitchAccessible
----------------==  GtkTable
-- 需要patch GtkTable["constructor"]的new
Gtk324.GtkTable.constructor["new"] = { gencode = "gtk_table_new((guint)({* this['n-rows'].value *}), (guint)({* this['n-columns'].value *}), (gboolean)({* this.homogeneous.value *}))",
                                   params = { type = {"guint", "guint", "gboolean"}, name = {"n-rows", "n-columns", "homogeneous"} } };

-- 需要patch GtkTable_property的column_spacing
Gtk324.GtkTable.property["column-spacing"]["__gencode__"] = {'gtk_table_set_col_spacings((GtkTable*){* id *}, (guint){* property.value *})'}
Gtk324.GtkTable.property["row-spacing"]["__gencode__"]    = {'gtk_table_set_row_spacings((GtkTable*){* id *}, (guint){* property.value *})'}
-- 可减少警告信息
Gtk324.GtkTable.property["n-rows"]["__construct__"] = 1
Gtk324.GtkTable.property["n-columns"]["__construct__"] = 1

Gtk324.GtkTable.property["__group__"] = {
    {
        -- 用于判断是否属于当前组
        group = {"n-rows", "n-columns"},
        -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
        group_code = {
            {name = {"n-rows", "n-columns"}, gen_code = "gtk_table_resize((GtkTable*){* id *}, {* this[\"n-rows\"].value *}, {* this[\"n-columns\"].value *})" },
        }
    },
};

-- GtkTable的child property属性生成代码
Gtk324.GtkTable["packing"] = {
    {
        -- 用于判断是否属于当前组
        group = {}, group_code = { { name = {"left_attach", "right_attach", "top_attach", "bottom_attach", "x_options", "y_options", "x_padding", "y_padding"}, 
            gen_code = "gtk_table_attach((GtkTable*){* id *}, (GtkWidget*){* child.id.value *}, {* packing['left-attach'].value *}, {* packing['right-attach'].value *}, {* packing['top-attach'].value *}, {* packing['bottom-attach'].value *}, (GtkAttachOptions)({* packing['x-options'].value *}), (GtkAttachOptions)({* packing['y-options'].value *}), {* packing['x-padding'].value *}, {* packing['y-padding'].value *})"},
        }
    },
};

----------------==  GtkTextView
----------------==  GtkToolItemGroup
Gtk324.GtkToolItemGroup["packing"] = {
    {
        group = {"position"}, group_code = { { name = {"position"},  
            gen_code = "gtk_tool_item_group_insert((GtkToolItemGroup*){* id *}, (GtkToolItem*){* child.id.value *}, (gint)({* packing.position.value *}))"}},
    },
    {
        group = {"expand"}, group_code = { { name = {"expand"},
            gen_code = "gtk_container_child_set_property((GtkContainer*){* id *}, (GtkWidget*){* child.id.value *}, \"expand\", (gint)({* packing.expand.value *}), NULL)"}},
    },
    {
        group = {"fill"}, group_code = { { name = {"fill"},
            gen_code = "gtk_container_child_set_property((GtkContainer*){* id *}, (GtkWidget*){* child.id.value *}, \"fill\", (gint)({* packing.fill.value *}), NULL)"}},
    },
    {
        group = {"homogeneous"}, group_code = { { name = {"homogeneous"},
            gen_code = "gtk_container_child_set_property((GtkContainer*){* id *}, (GtkWidget*){* child.id.value *}, \"homogeneous\", (gint)({* packing.homogeneous.value *}), NULL)"}},
    },
    {
        group = {"new-row"}, group_code = { { name = {"new-row"},
            gen_code = "gtk_container_child_set_property((GtkContainer*){* id *}, (GtkWidget*){* child.id.value *}, \"new-row\", (gint)({* packing[\"new-row\"].value *}), NULL)"}},
    },
};

----------------==  GtkToolPalette
Gtk324.GtkToolPalette.property["toolbar-style"].__gencode__ = {"gtk_tool_palette_set_style((GtkToolPalette*)({* id *}), (GtkToolbarStyle)({* property.value *}))"};
Gtk324.PatchGlibProperty(Gtk324.GtkToolPalette, {"icon-size-set"});

Gtk324.GtkToolPalette.packing = Gtk324.copy_and_insert_more(Gtk324.GtkToolPalette.parent.packing,
    {
        group = {"exclusive"}, group_code = { { name = {"exclusive"},
            gen_code = "gtk_tool_palette_set_exclusive((GtkToolPalette*){* id *}, (GtkToolItemGroup*){* child.id.value *}, (gboolean)({* packing.exclusive.value *}))"}},
    },
    {
        group = {"expand"}, group_code = { { name = {"expand"},
            gen_code = "gtk_tool_palette_set_expand((GtkToolPalette*){* id *}, (GtkToolItemGroup*){* child.id.value *}, (gboolean)({* packing.expand.value *}))"}},
    }
);

----------------==  GtkToolbar
Gtk324.GtkToolbar.property["toolbar-style"].__gencode__ = {"gtk_toolbar_set_style((GtkToolbar*)({* id *}), (GtkToolbarStyle)({* property.value *}))"};
Gtk324.PatchGlibProperty(Gtk324.GtkToolbar, {"icon-size-set"});

Gtk324.GtkToolbar.packing = {
    {
        group = {}, group_code = { { name = {}, 
            gen_code = "gtk_toolbar_insert((GtkToolbar*){* id *}, (GtkToolItem*){* child.id.value *}, -1)"}},
    },
    {
        group = {"homogeneous"}, group_code = { { name = {"homogeneous"},
            gen_code = "gtk_tool_item_set_homogeneous((GtkToolItem*){* id *}, (gboolean)({* packing.homogeneous.value *}))"}},
    },
    {
        group = {"expand"}, group_code = { { name = {"expand"},
            gen_code = "gtk_tool_item_set_expand((GtkToolItem*){* id *}, (gboolean)({* packing.expand.value *}))"}},
    },
};

----------------==  GtkTreeView
Gtk324.GtkTreeView.property["enable-grid-lines"]["__gencode__"] = {"gtk_tree_view_set_grid_lines((GtkTreeView*)({* id *}), (GtkTreeViewGridLines)({* property.value *}))"};
-- 添加一个子属性
Gtk324.GtkTreeView.child_property = { ["internal_child"] = {__type__="gchar*"   ,__default__ = "NULL"}};
Gtk324.GtkTreeView["packing"] = {
    {
        -- 如果是内部GtkTreeSelection，则不需要关联代码
        group = {"internal_child"}, group_code = { { name = {"internal_child"},  can_skip = true, gen_code = ""}},
    },
    {
        group = {}, group_code = { { name = {},  gen_code = "gtk_tree_view_append_column((GtkTreeView*){* id *}, (GtkTreeViewColumn*){* child.id.value *})"}},
    },
};

----------------==  GtkVSeparator
----------------==  GtkAccelLabel
Gtk324.GtkAccelLabel.constructor.new = { gencode = "gtk_accel_label_new((const gchar*)({* this.label.value *}))",
                                        params = { type = {"gchar*"}, name = {"label"} } };

----------------==  GtkActionBar
----------------==  GtkAlignment
-- GtkAlignment的组合属性
Gtk324.PatchGlibProperty(Gtk324.GtkAlignment, {"xalign", "yalign", "xscale", "yscale"});
Gtk324.GtkAlignment.property["__group__"] = {
    {
        -- 用于判断是否属于当前组
        group = {"bottom-padding", "left-padding", "right-padding", "top-padding"},
        -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
        group_code = {
            {name = {"bottom-padding", "left-padding", "right-padding", "top-padding"}, gen_code = "gtk_alignment_set_padding((GtkAlignment*){* id *}, (guint){* this['top-padding'].value *}, (guint){* this['bottom-padding'].value *}, (guint){* this['left-padding'].value *}, (guint){* this['right-padding'].value *})" },
        }
    },
};

----------------==  GtkAppChooserWidget
----------------==  GtkBooleanCellAccessible
----------------==  GtkButton
--- 添加完善GtkButton的三个属性的设置代码，用于某些特殊的internal-child场景
Gtk324.GtkButton.property.label.__gencode__ = {"gtk_button_set_label((GtkButton*)({* id *}), (const gchar*)({* property.value *}))"};
Gtk324.GtkButton.property['use-stock'].__gencode__ = {"gtk_button_set_use_stock((GtkButton*)({* id *}), (gboolean)({* property.value *}))"};
Gtk324.GtkButton.property['use-underline'].__gencode__ = {"gtk_button_set_use_underline((GtkButton*)({* id *}), (gboolean)({* property.value *}))"};
-- GtkButton的构建函数new_from_stock需要patch
Gtk324.GtkButton.constructor["new_from_stock"] = {  gencode = "gtk_button_new_from_stock((const gchar*)({* this.label.value *}))",
                                                params = { type = {"gchar*", "gboolean"}, name = {"label", "use-stock"} } };

-- GtkButton的构建函数new_with_mnemonic需要patch
Gtk324.GtkButton.constructor["new_with_mnemonic"] = {  gencode = "gtk_button_new_with_mnemonic((const gchar*)({* this.label.value *}))",
                                                params = { type = {"gchar*", "gboolean"}, name = {"label", "use-underline"} } };

-- GtkButton的组合属性
Gtk324.GtkButton.property["__group__"] = {
    {
        -- 用于判断是否属于当前组
        group = {"xalign", "yalign"},
        -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
        group_code = {
            {name = {"xalign", "yalign"}, gen_code = "gtk_button_set_alignment((GtkButton*){* id *}, (gfloat){* this.xalign.value *}, (gfloat){* this.yalign.value *})" },
        }
    },
};

----------------==  GtkButtonAccessible
----------------==  GtkButtonBox
-- GtkButtonBox的layout_style属性对应的代码生成函数
Gtk324.GtkButtonBox.property["layout-style"]["__gencode__"] = {"gtk_button_box_set_layout((GtkButtonBox*)({* id *}), (GtkButtonBoxStyle)({* property.value *}))"};
-- 影子拷贝，然后再插入一项
Gtk324.GtkButtonBox.packing = Gtk324.copy_and_insert_more(Gtk324.GtkButtonBox.parent.packing,
    {
        group = {"secondary"}, group_code = { { name = {"secondary"}, can_skip = true, 
            gen_code = "gtk_button_box_set_child_secondary((GtkButtonBox*){* id *}, (GtkWidget*){* child.id.value *}, (gboolean)({* packing.secondary.value *}))"}}
    }
);

----------------==  GtkColorChooserWidget
----------------==  GtkColorSelection
----------------==  GtkComboBox
Gtk324.GtkComboBox.child_property = { ["internal_child"] = {__type__="gchar*"   ,__default__ = "NULL"}};
--- 增加一个辅助类
Gtk324.GtkComboBoxChildEntry = {
  class = "GtkComboBoxChildEntry", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_bin_get_child(GTK_BIN({* parent.property.id.value *}))", 
            params = { type = {"gboolean"}, name = {"internal_child"} } },
  },
  signal = {
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = {
    -- 属性名称  属性类型 缺省值 代码生成
    internal_child       = {__type__="gboolean", macro_code = {uiheaders = "COMBOBOX_CHILD_ENTRY_DEFINE"}},
  },
  parent = Gtk324.GtkEntry,
};
-- GtkComboBox的构建函数new_text/new_with_entry/new_with_model_and_entry需要patch
Gtk324.GtkComboBox["packing"] = {
    {
        -- 如果是内部GtkEntry，则不需要关联代码
        group = {"internal_child"}, group_code = { { name = {"internal_child"}, can_skip = true, gen_code = ""}},
    },
};

--Gtk324.GtkComboBox.constructor.new_text.params = { type = {"GtkTreeModel*"}, name = {"model"} };
Gtk324.GtkComboBox.constructor.new_with_area = {
    gencode = "gtk_combo_box_new_with_area((GtkCellArea*)({* this['cell-area'].value *}))", 
    params = { type = {"GtkCellArea*"}, name = {"cell-area"} }
};
Gtk324.GtkComboBox.constructor.new_with_area_and_entry = {
    gencode = "gtk_combo_box_new_with_area_and_entry((GtkCellArea*)({* this['cell-area'].value *}))", 
    params = { type = {"GtkCellArea*", "gboolean"}, name = {"cell-area", "has-entry"} }
};
Gtk324.GtkComboBox.constructor.new_with_entry.params = { type = {"gboolean"}, name = {"has_entry"} };
Gtk324.GtkComboBox.constructor.new_with_model_and_entry.params = { type = {"GtkTreeModel*", "gboolean"}, name = {"model", "has_entry"} };

Gtk324.GtkComboBox.property['tearoff-title'].__gencode__ = {"gtk_combo_box_set_title((GtkComboBox*)({* id *}), (const gchar*)({* property.value *}))"};
Gtk324.PatchGlibProperty(Gtk324.GtkComboBox, {"has-frame"});

----------------==  GtkComboBoxAccessible
----------------==  GtkEventBox
----------------==  GtkExpander
Gtk324.GtkExpander.constructor.new_with_mnemonic.params = { type = {"const gchar*", "gboolean"}, name = {"label", "use_underline"} }
Gtk324.GtkExpander.property.expanded.__gencode__ = {"gtk_expander_set_expanded((GtkExpander*)({* id *}), (gboolean)({* property.value *}))"};
Gtk324.GtkExpander.property['use-markup'].__gencode__ = {"gtk_expander_set_use_markup((GtkExpander*)({* id *}), (gboolean)({* property.value *}))"};
Gtk324.PatchGlibProperty(Gtk324.GtkExpander, {"label-fill"});

----------------==  GtkExpanderAccessible
----------------==  GtkFileChooserButton
-- 判断构造函数的顺序，new_with_dialog需要首先判断

----------------==  GtkFileChooserWidget
Gtk324.GtkFileChooserWidget.constructor.new_with_backend = { gencode = "gtk_file_chooser_button_new_with_backend((const gchar*)({* this.title.value *}), (GtkFileChooserAction)({* this.action.value *}), (const gchar*)({* this['file-system-backend'].value *}))",
                                            params = { type = {"GtkFileChooserAction", "const gchar*"},
                                                    name = {"action", "file-system-backend"}}};

----------------==  GtkFileChooserWidgetAccessible
----------------==  GtkFlowBoxAccessible
----------------==  GtkFlowBoxChild
----------------==  GtkFlowBoxChildAccessible
----------------==  GtkFontChooserWidget
----------------==  GtkFontSelection
----------------==  GtkFrame
Gtk324.GtkFrame.property["__group__"] = {
    {
        -- 用于判断是否属于当前组
        group = {"label-xalign", "label-yalign"},
        -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
        group_code = {
            {name = {"label-xalign", "label-yalign"}, gen_code = "gtk_frame_set_label_align((GtkFrame*){* id *}, (gfloat){* this['label-xalign'].value *}, (gfloat){* this['label-yalign'].value *})" },
        }
    },
};

----------------==  GtkFrameAccessible
----------------==  GtkGestureDrag
----------------==  GtkGestureLongPress
----------------==  GtkGestureMultiPress
----------------==  GtkGestureStylus
----------------==  GtkGestureSwipe
----------------==  GtkHBox
----------------==  GtkHPaned
----------------==  GtkHScale
Gtk324.GtkHScale.constructor.new_with_range = nil

----------------==  GtkHScrollbar
----------------==  GtkHandleBox
Gtk324.PatchGlibProperty(Gtk324.GtkHandleBox, {"snap-edge-set"});

----------------==  GtkHeaderBarAccessible
----------------==  GtkIconViewAccessible
----------------==  GtkImageCellAccessible
----------------==  GtkInfoBar
Gtk324.GtkInfoBar.constructor.new_with_buttons = nil;
-- 子属性，用于区分packing
Gtk324.GtkInfoBar.child_property = {
    -- 属性名称  属性类型 缺省值
    action_area    = {__type__="guint"},
    content_area   = {__type__="guint"},
    -- 这个响应ID，允许有默认值，为0
    response       = {__type__="guint"  ,__default__ = "0" },
};

-- 另外的构建属性则继承自Gtk324的GtkBox的packing属性
Gtk324.GtkInfoBar.packing = Gtk324.copy_and_insert_more(Gtk324.GtkBox.packing, -- Gtk324.GtkInfoBar.parent.packing,
    -- 添加其他的匹配关系
    {
        group = {"action_area", "response"}, group_code = { { name = {"action_area", "response"}, 
            gen_code = "gtk_info_bar_add_action_widget((GtkInfoBar*){* id *}, (GtkWidget*){* child.id.value *}, {* packing.response.value *})"}
        }
    },
    {
        group = {"content_area"}, group_code = { { name = {"content_area", "expand", "fill", "padding"}, 
            gen_code = "gtk_box_pack_start((GtkBox*)gtk_info_bar_get_content_area({* id *}), (GtkWidget*){* child.id.value *}, {* packing.expand.value *}, {* packing.fill.value *}, {* packing.padding.value *})"}
        }
    }
);

----------------==  GtkListBoxAccessible
----------------==  GtkListBoxRow
----------------==  GtkListBoxRowAccessible
----------------==  GtkMenu
Gtk324.GtkMenu.packing = {
    {
        -- 如果有如下四个参数的一个，则应该使用gtk_menu_attach关联
        group = {"bottom_attach", "left_attach", "right_attach", "top_attach"}, group_or_check=true, group_code = { { name = {"bottom_attach", "left_attach", "right_attach", "top_attach"}, 
            gen_code = "gtk_menu_attach((GtkMenu*){* id *}, (GtkWidget*)({* child.id.value *}), (gboolean)({* packing.left_attach.value *}), (gboolean)({* packing.right_attach.value *}), (gboolean)({* packing.top_attach.value *}), (gboolean)({* packing.bottom_attach.value *}))"},
        },
    }
    -- 否则会调用到GtkMenuShell的gtk_menu_shell_append
};
Gtk324.GtkMenu.property['tearoff-title'].__gencode__ = {"gtk_menu_set_title((GtkMenu*)({* id *}), (const gchar*)({* property.value *}))"};
Gtk324.PatchGlibProperty(Gtk324.GtkMenu, {"anchor-hints", "attach-widget", "menu-type-hint", "rect-anchor-dx", "rect-anchor-dy"});

----------------==  GtkMenuBar
----------------==  GtkMenuItem
-- GtkMenuItem的构建函数不需要修改，其params需要添加一项
Gtk324.GtkMenuItem.constructor.new_with_mnemonic.params = { type = {"const gchar*", "gboolean"}, name = {"label", "use-underline"} };
-- GtkMenuItem的child property属性生成代码，在这里使用gtk_container_add
Gtk324.GtkMenuItem["packing"] = {
    {
        -- 用于判断是否属于当前组
        group = {},
        group_code = {
            {name = {}, gen_code = "gtk_menu_item_set_submenu((GtkMenuItem*)({* id *}), (GtkWidget*){* child.id.value *})"}
        },
    },
};

----------------==  GtkMenuItemAccessible
----------------==  GtkMenuShellAccessible
----------------==  GtkNotebookAccessible
----------------==  GtkOverlay
----------------==  GtkPanedAccessible
----------------==  GtkPopover
----------------==  GtkPopoverAccessible
----------------==  GtkRecentChooserWidget
--  GtkRecentChooserWidget ，属性来自于GtkRecentChooser
Gtk324.GtkRecentChooserWidget.constructor.new_for_manager = { gencode = "gtk_recent_chooser_widget_new_for_manager((GtkRecentManager*)({* this['recent-manager'].value *}))",
                                                    params = { type = {"GtkRecentManager*"}, name = {"recent-manager"} } };

----------------==  GtkRevealer
----------------==  GtkScaleAccessible
----------------==  GtkScrolledWindow
Gtk324.GtkScrolledWindow.property.hadjustment.__default__ = "NULL";
Gtk324.GtkScrolledWindow.property.vadjustment.__default__ = "NULL";
Gtk324.GtkScrolledWindow.property['window-placement'].__gencode__ = {"gtk_scrolled_window_set_placement((GtkScrolledWindow*){* id *}, (GtkCornerType)({* property.value *}))"};
Gtk324.PatchGlibProperty(Gtk324.GtkScrolledWindow, {'window-placement-set'});

Gtk324.GtkScrolledWindow.property["__group__"] = {
    {
        -- 用于判断是否属于当前组
        group = {"hscrollbar-policy", "vscrollbar-policy"},
        -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
        group_code = {
            {name = {"hscrollbar-policy", "vscrollbar-policy"}, gen_code = "gtk_scrolled_window_set_policy((GtkScrolledWindow*){* id *}, (GtkPolicyType){* this['hscrollbar-policy'].value *}, (GtkPolicyType){* this['vscrollbar-policy'].value *})" },
        }
    },
};

----------------==  GtkScrolledWindowAccessible
----------------==  GtkSearchBar
----------------==  GtkShortcutLabel
----------------==  GtkShortcutsGroup
----------------==  GtkShortcutsSection
----------------==  GtkShortcutsShortcut
----------------==  GtkSocketAccessible
----------------==  GtkSpinButtonAccessible
----------------==  GtkStackAccessible
----------------==  GtkStackSidebar
----------------==  GtkStackSwitcher
----------------==  GtkStatusbar
----------------==  GtkStatusbarAccessible
----------------==  GtkTextCellAccessible
----------------==  GtkTextViewAccessible
----------------==  GtkToolItem
----------------==  GtkTreeViewAccessible
----------------==  GtkVBox
----------------==  GtkVPaned
----------------==  GtkVScale
Gtk324.GtkVScale.constructor.new_with_range = nil

----------------==  GtkVScrollbar
----------------==  GtkViewport
----------------==  GtkWindow
Gtk324.GtkWindow.property["^z_accel_group_%d+$"] = {__type__="GtkAccelGroup*", regex = true,
                is_top_widget = true, ext_depend = true, macro_code = {uisources = "TOP_WIDGET"},
                __gencode__ = {"gtk_window_add_accel_group((GtkWindow*){* id *}, (GtkAccelGroup*)({* property.value *}))"}};
Gtk324.GtkWindow.property['window-position'].__gencode__ = {"gtk_window_set_position((GtkWindow*)({* id *}), (GtkWindowPosition)({* property.value *}))"};
Gtk324.GtkWindow.property["__group__"] = {
    {
        -- 用于判断是否属于当前组
        group = {"allow-grow", "allow-shrink"},
        -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
        group_code = {
            {name = {"allow-grow", "allow-shrink"}, gen_code = "gtk_window_set_policy((GtkWindow*){* id *}, (gboolean){* this['allow-shrink'].value *}, (gboolean){* this['allow-grow'].value *}, TRUE)" },
        }
    },
    {
        -- 用于判断是否属于当前组
        group = {"default-height", "default-width"},
        -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
        group_code = {
            {name = {"default-height", "default-width"}, gen_code = "gtk_window_set_default_size((GtkWindow*){* id *}, (gint){* this['default-width'].value *}, (gint){* this['default-height'].value *})" },
        }
    },
};

----------------==  GtkWindowAccessible
----------------==  GtkAppChooserButton
----------------==  GtkApplicationWindow
----------------==  GtkAspectFrame
Gtk324.GtkAspectFrame.property["__group__"] = {
  {
      -- 用于判断是否属于当前组
      group = {"xalign", "yalign", "ratio", "obey_child"},
      -- 当前组内，用于生成代码的允许多种组合，匹配顺序为从上往下
      group_code = { {name = {"xalign", "yalign", "ratio", "obey_child"}, 
          gen_code = "gtk_aspect_frame_set((GtkAspectFrame*){* id *}, (gfloat){* this.xalign.value *}, (gfloat){* this.yalign.value *}, (gfloat){* this.ratio.value *}, (gboolean){* this.obey_child.value *})" },
      }
  },
};
----------------==  GtkAssistant
-- GtkAssistant的child property属性生成代码，使用组合器
Gtk324.GtkAssistant["packing"] = {
    {
        group = {}, group_code = { { name = {}, 				                          
            gen_code = "gtk_assistant_append_page((GtkAssistant*){* id *}, (GtkWidget*){* child.id.value *})"}}
    },
    {
        group = {"complete"}, group_code = { { name = {"complete"},
            gen_code = "gtk_assistant_set_page_complete((GtkAssistant*){* id *}, (GtkWidget*){* child.id.value *}, (gboolean){* packing.complete.value *})"}}
    },
    {
        group = {"header_image"}, group_code = { { name = {"header_image"},
            gen_code = "gtk_assistant_set_page_header_image((GtkAssistant*){* id *}, (GtkWidget*){* child.id.value *}, (GdkPixbuf*){* packing.header_image.value *})"}}
    },
    {
        group = {"page_type"}, group_code = { { name = {"page_type"},
            gen_code = "gtk_assistant_set_page_type((GtkAssistant*){* id *}, (GtkWidget*){* child.id.value *}, (GtkAssistantPageType){* packing.page_type.value *})"}}
    },
    {
        group = {"sidebar_image"}, group_code = { { name = {"sidebar_image"},
            gen_code = "gtk_assistant_set_page_side_image((GtkAssistant*){* id *}, (GtkWidget*){* child.id.value *}, (GdkPixbuf*){* packing.sidebar_image.value *})"}}
    },
    {
        group = {"title"}, group_code = { { name = {"title"},
            gen_code = "gtk_assistant_set_page_title((GtkAssistant*){* id *}, (GtkWidget*){* child.id.value *}, (const gchar*){* packing.title.value *})"}}
    }
};

----------------==  GtkCheckMenuItem
Gtk324.GtkCheckMenuItem.constructor.new_with_mnemonic.params = { type = {"const gchar*", "gboolean"}, name = {"label", "use-underline"} };

----------------==  GtkCheckMenuItemAccessible
----------------==  GtkColorButton
----------------==  GtkComboBoxText
-- GtkComboBoxText的构建函数new_with_entry需要patch
Gtk324.GtkComboBoxText.constructor.new_with_entry.params = { type = {"gboolean"}, name = {"has-entry"} };
---  GtkComboBoxText，需要增加一个正则属性处理
Gtk324.GtkComboBoxText.property["^text_item_%d+$"] = {__type__="gchar*", regex = true,
                              __gencode__ = {"gtk_combo_box_text_append_text((GtkComboBoxText*){* id *}, (gchar*){* property.value *})"}};

----------------==  GtkDialog
Gtk324.GtkDialog.constructor.new_with_buttons = nil;
Gtk324.GtkDialog.child_property = { 
  internal_child       = {__type__="gchar*"},
};
-- GtkVBox如果带internal_child子属性，则不需要生成关联代码
Gtk324.GtkDialog["packing"] = {
  {
      -- 用于判断是否属于当前组
      group = {"internal_child"}, group_code = { { name = {"internal_child"}, can_skip = true, gen_code = ""}},
  },
};

--- 增加四个辅助类:
Gtk324.GtkDialogChildGtkVBox = {
  class = "GtkDialogChildGtkVBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_dialog_get_content_area((GtkDialog*){* this.dialog_id.value *})", 
            params = { type = {"GtkDialog*"}, name = {"dialog_id"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = {
    -- 属性名称  属性类型 缺省值 代码生成
    dialog_id            = {__type__="GtkDialog*", macro_code = {uiheaders = "DIALOG_CHILD_VBOX_DEFINE"}},
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    internal_child       = {__type__="gchar*"},
    information          = {__type__="gboolean"},
  },
  packing = {
    {
        group = {"internal_child"}, group_code = {
            -- 需要忽略掉这些packing属性的配置
            { name = {"internal_child"}, can_skip = true, gen_code = ""},
            { name = {}, filter_out = {"expand", "fill", "pack_type", "padding", "position"}, can_skip = true, gen_code = ""} }
    },
    {
        -- 忽略掉pack_type与position
        group = {"information"}, group_code = { { name = {"information", "expand", "fill", "padding"}, filter_out = {"pack_type", "position"}, 
            gen_code = "gtk_box_pack_start((GtkBox*){* id *}, (GtkWidget*){* child.id.value *}, {* packing.expand.value *}, {* packing.fill.value *}, {* packing.padding.value *})"}}
    },
  },
  parent = Gtk324.GtkVBox,
};
Gtk324.GtkDialogChildGtkBox = {
  class = "GtkDialogChildGtkBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_dialog_get_content_area((GtkDialog*){* this.dialog_id.value *})", 
            params = { type = {"GtkDialog*"}, name = {"dialog_id"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = {
    -- 属性名称  属性类型 缺省值 代码生成
    dialog_id            = {__type__="GtkDialog*", macro_code = {uiheaders = "DIALOG_CHILD_BOX_DEFINE"}},
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    internal_child       = {__type__="gchar*"},
    information          = {__type__="gboolean"},
  },
  packing = {
    {
        group = {"internal_child"}, group_code = { { name = {"internal_child"}, can_skip = true, gen_code = ""}},
    },
    {
        group = {"information"}, group_code = { { name = {"information", "expand", "fill", "padding"}, 
            gen_code = "gtk_box_pack_start((GtkBox*){* id *}, (GtkWidget*){* child.id.value *}, {* packing.expand.value *}, {* packing.fill.value *}, {* packing.padding.value *})"}
        }
    },
  },
  parent = Gtk324.GtkBox,
};

Gtk324.GtkDialogChildGtkHButtonBox = {
  class = "GtkDialogChildGtkHButtonBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_dialog_get_action_area((GtkDialog*){* this.dialog_id.value *})", 
            params = { type = {"GtkDialog*"}, name = {"dialog_id"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = {
    -- 属性名称  属性类型 缺省值 代码生成
    dialog_id            = {__type__="GtkDialog*", macro_code = {uiheaders = "DIALOG_CHILD_HBUTTON_BOX_DEFINE"}},
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    response             = {__type__="gboolean"},
    dialog_id            = {__type__="GtkDialog*"},
  },
  packing = {
    {
        -- 用于判断是否属于当前组，"secondary"属性现在可以自动递归时处理了
        group = {"response", "dialog_id"}, 
        group_code = { 
            { name = {"response", "dialog_id"}, filter_out = {"expand", "fill", "pack_type", "padding", "position"},
              gen_code = "gtk_dialog_add_action_widget((GtkDialog*){* packing.dialog_id.value *}, (GtkWidget*){* child.id.value *}, {* packing.response.value *})"}
        },
    },
  },
  parent = Gtk324.GtkHButtonBox,
};
Gtk324.GtkDialogChildGtkButtonBox = {
  class = "GtkDialogChildGtkButtonBox", 
  constructor = { 
    -- 名称[- ==> _], 
    new = { gencode = "gtk_dialog_get_action_area((GtkDialog*){* this.dialog_id.value *})", 
            params = { type = {"GtkDialog*"}, name = {"dialog_id"} } },
  },
  signal = { 
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = {
    -- 属性名称  属性类型 缺省值 代码生成
    dialog_id            = {__type__="GtkDialog*", macro_code = {uiheaders = "DIALOG_CHILD_BUTTON_BOX_DEFINE"}},
  },
  child_property = { 
    -- 属性名称  属性类型 缺省值 代码生成
    response             = {__type__="gboolean"},
    dialog_id            = {__type__="GtkDialog*"},
  },
  packing = {
    {
        -- 用于判断是否属于当前组，"secondary"属性现在可以自动递归时处理了
        group = {"response", "dialog_id"},
        group_code = {
            { name = {"response", "dialog_id"}, filter_out = {"expand", "fill", "pack_type", "padding", "position"},
              gen_code = "gtk_dialog_add_action_widget((GtkDialog*){* packing.dialog_id.value *}, (GtkWidget*){* child.id.value *}, {* packing.response.value *})"}
        },
    },
  },
  parent = Gtk324.GtkButtonBox,
};


----------------==  GtkFontButton
-- GtkFontButton的构建函数
Gtk324.GtkFontButton.constructor["new_with_font"] = { gencode = "gtk_font_button_new_with_font((const gchar*)({* this['font-name'].value *}))",
												  params = { type = {"gchar*"}, name = {"font-name"} } };

----------------==  GtkGesturePan
----------------==  GtkHButtonBox
----------------==  GtkImageMenuItem
-- 需要修改生成代码，且变更过滤器
Gtk324.GtkImageMenuItem.constructor.new_from_stock = {
    gencode = "gtk_image_menu_item_new_from_stock((const gchar*)({* this.label.value *}), (GtkAccelGroup*)({* this['accel-group'].value *}))",
    params = { type = {"const gchar*", "GtkAccelGroup*", "gboolean"},
               name = {"label", "accel-group", "use-stock"} }
};
Gtk324.GtkImageMenuItem.constructor.new_from_stock2 = {
    gencode = "gtk_image_menu_item_new_from_stock((const gchar*)({* this.label.value *}), (GtkAccelGroup*)(NULL))",
    params = { type = {"const gchar*", "gboolean"},
             name = {"label", "use-stock"} }
};
-- 不修改生成代码，只变更过滤器器
Gtk324.GtkImageMenuItem.constructor.new_with_mnemonic.params = { type = {"const gchar*", "gboolean"}, name = {"label", "use-underline"} };
-- 判断构造函数的顺序
Gtk324.GtkImageMenuItem.constructor.__sort__ = {
  "new_from_stock",
  "new_from_stock2", -- new_from_stock2必须在new_with_mnemonic之前
  "new_with_mnemonic",
  "new_with_label",
  "new"
};

----------------==  GtkLinkButton
----------------==  GtkLinkButtonAccessible
----------------==  GtkLockButton
----------------==  GtkLockButtonAccessible
----------------==  GtkMenuAccessible
----------------==  GtkModelButton
----------------==  GtkOffscreenWindow
----------------==  GtkPlacesSidebar
----------------==  GtkPlug
Gtk324.GtkPlug.constructor = {
    new             = { gencode = "gtk_plug_new((GdkWindow*)({* this['socket-window'].value *}))",
                        params = { type = {"GdkWindow*"}, name = {"socket-window"} } }
};

----------------==  GtkPlugAccessible
----------------==  GtkPopoverMenu
----------------==  GtkRecentChooserMenu
--  GtkRecentChooserMenu ，属性来自于GtkRecentChooser
Gtk324.GtkRecentChooserMenu.constructor.new_for_manager = { gencode = "gtk_recent_chooser_menu_new_for_manager((GtkRecentManager*)({* this['recent-manager'].value *}))",
                                                    params = { type = {"GtkRecentManager*"}, name = {"recent-manager"} } };

----------------==  GtkScaleButton
Gtk324.GtkScaleButton.constructor.new = { gencode = "gtk_scale_button_new((GtkIconSize)({* this.size.value *}), (gdouble)(0), (gdouble)(0), (gdouble)(0), (const gchar**)(NULL))", 
                                          params = { type = {"GtkIconSize"}, 
                                                    name = {"size"} } };
Gtk324.GtkScaleButton.constructor.new_with_adj_icons = { gencode = "gtk_scale_button_new((GtkIconSize)({* this.size.value *}), (gdouble)gtk_adjustment_get_lower({* this.adjustment.value *}), (gdouble)gtk_adjustment_get_upper({* this.adjustment.value *}), (gdouble)gtk_adjustment_get_step_increment({* this.adjustment.value *}), (const gchar**)(NULL))", 
                                          params = { type = {"GtkIconSize", "GtkAdjustment*"}, 
                                                    name = {"size", "adjustment"} } };
Gtk324.GtkScaleButton.property.icons.__gencode__ = {"{ //",
                                                    "    const char* {* id *}_icons[] = { {* property.value *}, NULL}",
                                                    "    gtk_scale_button_set_icons((GtkScaleButton*)({* id *}), (const gchar**)({* id *}_icons))",
                                                    "} //"};
Gtk324.PatchGlibProperty(Gtk324.GtkScaleButton, {"size"});

----------------==  GtkScaleButtonAccessible
----------------==  GtkSeparatorMenuItem
----------------==  GtkSeparatorToolItem
----------------==  GtkShortcutsWindow
----------------==  GtkTearoffMenuItem
----------------==  GtkToggleButton
-- GtkToggleButton需要增加draw_indicator的gencode属性
Gtk324.GtkToggleButton.constructor.new_with_mnemonic.params = {type = {"const gchar*", "gboolean"}, name = {"label", "use-underline"} };

Gtk324.GtkToggleButton.property["draw-indicator"]["__gencode__"] = {"gtk_toggle_button_set_mode((GtkToggleButton*){* id *}, (gboolean){* property.value *})"}

----------------==  GtkToggleButtonAccessible
----------------==  GtkToolButton
----------------==  GtkVButtonBox
----------------==  GtkAboutDialog
Gtk324.GtkAboutDialog.property.artists.__gencode__ = {"{ //",
                                                      "    const char* {* id *}_artists[] = { {* property.value *}, NULL}",
                                                      "    gtk_about_dialog_set_artists((GtkAboutDialog*)({* id *}), (const gchar**)({* id *}_artists))",
                                                      "} //"};
Gtk324.GtkAboutDialog.property.authors.__gencode__ = {"{ //",
                                                      "    const char* {* id *}_authors[] = { {* property.value *}, NULL}",
                                                      "    gtk_about_dialog_set_authors((GtkAboutDialog*)({* id *}), (const gchar**)({* id *}_authors))",
                                                      "} //"};
Gtk324.GtkAboutDialog.property.documenters.__gencode__ = {"{ //",
                                                          "    const char* {* id *}_documenters[] = { {* property.value *}, NULL}",
                                                          "    gtk_about_dialog_set_documenters((GtkAboutDialog*)({* id *}), (const gchar**)({* id *}_documenters))",
                                                          "} //"};

----------------==  GtkAppChooserDialog
----------------==  GtkCheckButton
Gtk324.GtkCheckButton.constructor.new_with_mnemonic.params = { type = {"const gchar*", "gboolean"}, name = {"label", "use-underline"} };

----------------==  GtkColorChooserDialog
----------------==  GtkColorSelectionDialog
--- 增加两个辅助类
Gtk324.GtkColorSelDlgButton = {
  class = "GtkColorSelDlgButton",
  constructor = {
    -- 名称[- ==> _],
    new = { gencode = "GTK_GET_PROPERTY_WIDGET((GtkWidget*)({* parent.property.id.value *}), (const gchar*)({* this.internal_child.value *}))",
            params = { type = {"const gchar*"},
                       name = {"internal_child"} } },
  },
  signal = {
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = {
    -- 属性名称  属性类型 缺省值 代码生成
    internal_child       = {__type__="gchar*", macro_code = {uiheaders = "COLOR_SEL_BUTTON_DEFINE", uisources = "GTK_GET_PROPERTY_WIDGET"}},
  },
  parent = Gtk324.GtkButton,
};
Gtk324.GtkColorSelectionInterChild = {
  class = "GtkColorSelectionInterChild",
  constructor = {
    -- 名称[- ==> _],
    new = { gencode = "gtk_color_selection_dialog_get_color_selection((GtkColorSelectionDialog*)({* parent.property.id.value *}) )",
            params = { type = {"const gchar*"},
                       name = {"internal_child"} } },
  },
  signal = {
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = {
    -- 属性名称  属性类型 缺省值 代码生成
    internal_child       = {__type__="gchar*", macro_code = {uiheaders = "COLOR_SEL_INTER_CHILD_DEFINE"}},
  },
  parent = Gtk324.GtkColorSelection,
};

-- 拷贝父类的父子关联
Gtk324.GtkColorSelectionDialog["packing"] = {
    {
        -- internal_child组，不需要建立父子关联
        group = {"internal_child"}, group_code = { {name = {"internal_child"}, can_skip = true, gen_code = ""}},
    },
    {
        -- 用于判断是否属于当前组
        group = {"response"}, group_code = {
            { name = {"response"}, 
              gen_code = "gtk_dialog_add_action_widget((GtkDialog*){* id *}, (GtkWidget*){* child.id.value *}, {* packing.response.value *})"},
            { name = {"position"}, can_skip = true,
              gen_code = "gtk_box_reorder_child((GtkBox*)gtk_dialog_get_action_area((GtkDialog*){* id *}), (GtkWidget*){* child.id.value *}, {* packing.position.value *})"},
        },
    }, 
    {
        -- 用于判断是否属于当前组
        group = {"information"}, group_code = {{ name = {"information", "expand", "fill", "padding"}, 
            gen_code = "gtk_box_pack_start((GtkBox*)gtk_dialog_get_content_area({* id *}), (GtkWidget*){* child.id.value *}, {* packing.expand.value *}, {* packing.fill.value *}, {* packing.padding.value *})"}
        },
    },
};

----------------==  GtkFileChooserDialog
Gtk324.GtkFileChooserDialog.constructor.new = { gencode = "gtk_file_chooser_dialog_new((const gchar*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}), (GtkFileChooserAction)({* this.action.value *}), (const gchar*)(NULL), NULL)",
                              params = { type = {"const gchar*", "GtkWindow*", "GtkFileChooserAction"},
                                        name = {"title", "parent", "action"} } };
Gtk324.GtkFileChooserDialog.constructor.new_with_backend = { gencode = "gtk_file_chooser_button_new_with_backend((const gchar*)({* this.title.value *}), (GtkFileChooserAction)({* this.action.value *}), (const gchar*)({* this['file-system-backend'].value *}))",
                                            params = { type = {"const gchar*", "GtkFileChooserAction", "const gchar*"},
                                                    name = {"title", "action", "file-system-backend"}}};

----------------==  GtkFontChooserDialog
----------------==  GtkFontSelectionDialog
--- 增加两个辅助类
Gtk324.GtkFontSelDlgButton = {
  class = "GtkFontSelDlgButton",
  constructor = {
    -- 名称[- ==> _],
    new = { gencode = "gtk_font_selection_dialog_get_{* this.internal_child.value *}((GtkFontSelectionDialog*)({* parent.property.id.value *}))",
            params = { type = {"gint"},
                       name = {"internal_child"} } },
  },
  signal = {
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = {
    -- 属性名称  属性类型 缺省值 代码生成
    internal_child       = {__type__="gint", macro_code = {uiheaders = "FONT_SEL_BUTTON_DEFINE"}},
  },
  parent = Gtk324.GtkButton,
};
Gtk324.GtkFontSelectionInterChild = {
  class = "GtkFontSelectionInterChild",
  constructor = {
    -- 名称[- ==> _],
    new = { gencode = "gtk_font_selection_dialog_get_font_selection((GtkFontSelectionDialog*)({* parent.property.id.value *}) )",
            params = { type = {"const gchar*"}, name = {"internal_child"} } },
  },
  signal = {
    -- 信号名称[- ==> _], 信号返回值, 信号参数列表
  },
  property = {
    -- 属性名称  属性类型 缺省值 代码生成
    internal_child       = {__type__="gchar*", macro_code = {uiheaders = "FONT_SEL_INTER_CHILD_DEFINE"}},
  },
  parent = Gtk324.GtkFontSelection,
};

Gtk324.GtkFontSelectionDialog["packing"] = Gtk324.GtkColorSelectionDialog["packing"];

----------------==  GtkMenuButton
----------------==  GtkMenuButtonAccessible
----------------==  GtkMenuToolButton
----------------==  GtkMessageDialog
Gtk324.GtkMessageDialog["packing"] = Gtk324.GtkDialog["packing"];
Gtk324.GtkMessageDialog.constructor = {
  -- 名称[- ==> _],
  new             = { gencode = "gtk_message_dialog_new((GtkWindow*)(NULL), GTK_DIALOG_DESTROY_WITH_PARENT, (GtkMessageType)({* this.message_type.value *}), (GtkButtonsType)({* this.buttons.value *}), (const gchar*)({* this.text.value *}))",
          params = { type = {"GtkMessageType", "GtkButtonsType", "gchar*"},
                      name = {"message-type", "buttons", "text"} } },
  new_with_markup = { gencode = "gtk_message_dialog_new_with_markup((GtkWindow*)(NULL), GTK_DIALOG_DESTROY_WITH_PARENT, (GtkMessageType)({* this.message_type.value *}), (GtkButtonsType)({* this.buttons.value *}), (const gchar*)({* this.text.value *}))",
          params = { type = {"GtkWindow*", "GtkMessageType", "GtkButtonsType", "gchar*", "gboolean"},
                     name = {"message-type", "buttons", "text", "use-markup"} } },
};
Gtk324.PatchGlibProperty(Gtk324.GtkMessageDialog, {"buttons", "message-type", "use-markup", "secondary-text", "secondary-use-markup"});

----------------==  GtkRadioButtonAccessible
----------------==  GtkRadioMenuItem
Gtk324.GtkRadioMenuItem.property["group"]["__gencode__"]  = {"gtk_radio_menu_item_set_group((GtkRadioMenuItem*)({* id *}), (GSList*)gtk_radio_menu_item_get_group({* property.value *}))"}

Gtk324.GtkRadioMenuItem.constructor = {
  -- 名称[- ==> _],
  new                           = {gencode = "gtk_radio_menu_item_new((GSList*)(0))", 
          params = { type = {}, 
                    name = {} } },
  new_from_widget              = { gencode = "gtk_radio_menu_item_new_from_widget((GtkRadioMenuItem*)({* this.group.value *}))",
          params = { type = {"GtkRadioMenuItem*"},
                    name = {"group"} } },
  new_with_label                = { gencode = "gtk_radio_menu_item_new_with_label((GSList*)(0), (const gchar*)({* this.label.value *}))",
          params = { type = {"const gchar*"},
                      name = {"label"} } },
  new_with_label_from_widget    = { gencode = "gtk_radio_menu_item_new_with_label_from_widget((GtkRadioMenuItem*)({* this.group.value *}), (const gchar*)({* this.label.value *}))",
          params = { type = {"GtkRadioMenuItem*", "const gchar*"},
                     name = {"group", "label"} } },
  new_with_mnemonic             = { gencode = "gtk_radio_menu_item_new_with_mnemonic((GSList*)(0), (const gchar*)({* this.label.value *}))",
          params = { type = {"const gchar*", "gboolean"},
                    name = {"label", "use_underline"}} },
  new_with_mnemonic_from_widget = { gencode = "gtk_radio_menu_item_new_with_mnemonic_from_widget((GtkRadioMenuItem*)({* this.group.value *}), (const gchar*)({* this.label.value *}))",
          params = { type = {"GtkRadioMenuItem*", "const gchar*", "gboolean"},
                     name = {"group", "label", "use_underline"}} },
};

----------------==  GtkRadioMenuItemAccessible
----------------==  GtkRecentChooserDialog
Gtk324.GtkRecentChooserDialog.constructor.new.gencode = "gtk_recent_chooser_dialog_new((const gchar*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}), (const gchar*)(NULL), 0)";
Gtk324.GtkRecentChooserDialog.constructor.new_for_manager = { gencode = "gtk_recent_chooser_dialog_new_for_manager((const gchar*)({* this.title.value *}), (GtkWindow*)({* this.parent.value *}), (GtkRecentManager*)({* this.manager.value *}), (const gchar*)(NULL), 0)", 
                                                              params = { type = {"const gchar*", "GtkWindow*", "GtkRecentManager*"}, 
                                                                        name = {"title", "parent", "manager"} } };

----------------==  GtkToggleToolButton
----------------==  GtkVolumeButton
----------------==  GtkRadioButton
Gtk324.GtkRadioButton.property["group"]["__gencode__"]  = {"gtk_radio_button_set_group((GtkRadioButton*)({* id *}), (GSList*)gtk_radio_button_get_group({* property.value *}))"}

Gtk324.GtkRadioButton.constructor = {
  -- 名称[- ==> _],
  new                           = {gencode = "gtk_radio_button_new((GSList*)(0))", 
          params = { type = {}, 
                    name = {} } },
  new_from_widget              = { gencode = "gtk_radio_button_new_from_widget((GtkRadioButton*)({* this.group.value *}))",
          params = { type = {"GtkRadioButton*"},
                    name = {"group"} } },
  new_with_label                = { gencode = "gtk_radio_button_new_with_label((GSList*)(0), (const gchar*)({* this.label.value *}))",
          params = { type = {"const gchar*"},
                      name = {"label"} } },
  new_with_label_from_widget    = { gencode = "gtk_radio_button_new_with_label_from_widget((GtkRadioButton*)({* this.group.value *}), (const gchar*)({* this.label.value *}))",
          params = { type = {"GtkRadioButton*", "const gchar*"},
                     name = {"group", "label"} } },
  new_with_mnemonic             = { gencode = "gtk_radio_button_new_with_mnemonic((GSList*)(0), (const gchar*)({* this.label.value *}))",
          params = { type = {"const gchar*", "gboolean"},
                    name = {"label", "use-underline"}} },
  new_with_mnemonic_from_widget = { gencode = "gtk_radio_button_new_with_mnemonic_from_widget((GtkRadioButton*)({* this.group.value *}), (const gchar*)({* this.label.value *}))",
          params = { type = {"GtkRadioButton*", "const gchar*", "gboolean"},
                     name = {"group", "label", "use-underline"}} },
};

----------------==  GtkRadioToolButton
Gtk324.GtkRadioToolButton.property["group"]["__gencode__"]  = {"gtk_radio_tool_button_set_group((GtkRadioToolButton*)({* id *}), (GSList*)gtk_radio_tool_button_get_group({* property.value *}))"}

Gtk324.GtkRadioToolButton.constructor = {
  -- 名称[- ==> _],
  new                            = {gencode = "gtk_radio_tool_button_new((GSList*)(0))", 
          params = { type = {}, 
                    name = {} } },
  new_from_stock                 = { gencode = "gtk_radio_tool_button_new_from_stock((GSList*)(0), (const gchar*)({* this[\"stock-id\"].value *}))",
          params = { type = {"const gchar*"},
                    name = {"stock-id"} } },
  new_from_widget                = { gencode = "gtk_radio_tool_button_new_from_widget((GtkRadioToolButton*)({* this.group.value *}))",
          params = { type = {"GtkRadioToolButton*"},
                      name = {"group"} } },
  new_with_stock_from_widget     = { gencode = "gtk_radio_tool_button_new_with_stock_from_widget((GtkRadioToolButton*)({* this.group.value *}), (const gchar*)({* this[\"stock-id\"].value *}))",
          params = { type = {"GtkRadioToolButton*", "const gchar*"},
                     name = {"group", "stock-id"} } },
};

----------------========================

---------------------  GtkTmplWidget示例，所有的模板类都格式与这个类相同，用于生成模板类的代码
--[[
Gtk324.GtkTmplWidget = {
  class = "GtkTmplWidget",
  constructor = {
    -- 名称[- ==> _],
    new = { gencode = "TMPL_WIDGET({* id *})",
            params = { type = {}, name = {} } },
  },
  signal = {
      -- 信号名称[- ==> _]， 信号返回值, 信号参数列表
  },
  property = {
    -- 属性名称  属性类型 缺省值 代码生成
    __parent_class__ = {__type__="gchar*" ,  __default__ = "NULL", __gencode__ = ""},
  },
  parent = nil,
};
]]--

------------------------  属性补丁，如下属性，依赖顶层控件，需要增加一个属性
Gtk324.GtkActivatable.property["related-action"].is_top_widget = true;
Gtk324.GtkEntryCompletion.property.model.is_top_widget = true;
Gtk324.GtkPrintOperation.property["default-page-setup"].is_top_widget = true;
Gtk324.GtkPrintOperation.property["print-settings"].is_top_widget = true;
Gtk324.GtkTextBuffer.property["tag-table"].is_top_widget = true;
Gtk324.GtkTreeModelSort.property.model.is_top_widget = true;
Gtk324.GtkRadioAction.property.group.is_top_widget = true;
Gtk324.GtkCellRendererCombo.property.model.is_top_widget = true;
Gtk324.GtkCellRendererSpin.property.adjustment.is_top_widget = true;
Gtk324.GtkIconView.property.model.is_top_widget = true;
--Gtk324.GtkLayout.property.hadjustment.is_top_widget = true;
--Gtk324.GtkLayout.property.vadjustment.is_top_widget = true;
--Gtk324.GtkProgressBar.property.adjustment.is_top_widget = true;
Gtk324.GtkSpinButton.property.adjustment.is_top_widget = true;
Gtk324.GtkTextView.property.buffer.is_top_widget = true;
Gtk324.GtkTreeView.property["expander-column"].is_top_widget = true;
--Gtk324.GtkTreeView.property.hadjustment.is_top_widget = true;
Gtk324.GtkTreeView.property.model.is_top_widget = true;
--Gtk324.GtkTreeView.property.vadjustment.is_top_widget = true;
Gtk324.GtkComboBox.property.model.is_top_widget = true;
Gtk324.GtkScrolledWindow.property.hadjustment.is_top_widget = true;
Gtk324.GtkScrolledWindow.property.vadjustment.is_top_widget = true;
--Gtk324.GtkViewport.property.hadjustment.is_top_widget = true;
--Gtk324.GtkViewport.property.vadjustment.is_top_widget = true;
Gtk324.GtkFileChooserButton.property.dialog.is_top_widget = true;
Gtk324.GtkScaleButton.property.adjustment.is_top_widget = true;
Gtk324.GtkEntry.property.buffer.is_top_widget = true;
Gtk324.GtkFileChooser.property.filter.is_top_widget = true;

-- 增加ext_depend属性，表示该属性需要依赖其他控件（有可能是顶层控件，也有可能是其他子控件）
Gtk324.GtkActivatable.property["related-action"].ext_depend = true;
Gtk324.GtkEntryCompletion.property.model.ext_depend = true;
Gtk324.GtkPrintOperation.property["default-page-setup"].ext_depend = true;
Gtk324.GtkPrintOperation.property["print-settings"].ext_depend = true;
Gtk324.GtkTextBuffer.property["tag-table"].ext_depend = true;
Gtk324.GtkTreeModelSort.property.model.ext_depend = true;
Gtk324.GtkRadioAction.property.group.ext_depend = true;
Gtk324.GtkCellRendererCombo.property.model.ext_depend = true;
Gtk324.GtkCellRendererSpin.property.adjustment.ext_depend = true;
Gtk324.GtkIconView.property.model.ext_depend = true;
--Gtk324.GtkLayout.property.hadjustment.ext_depend = true;
--Gtk324.GtkLayout.property.vadjustment.ext_depend = true;
--Gtk324.GtkProgressBar.property.adjustment.ext_depend = true;
Gtk324.GtkSpinButton.property.adjustment.ext_depend = true;
Gtk324.GtkTextView.property.buffer.ext_depend = true;
Gtk324.GtkTreeView.property["expander-column"].ext_depend = true;
--Gtk324.GtkTreeView.property.hadjustment.ext_depend = true;
Gtk324.GtkTreeView.property.model.ext_depend = true;
--Gtk324.GtkTreeView.property.vadjustment.ext_depend = true;
Gtk324.GtkComboBox.property.model.ext_depend = true;
Gtk324.GtkScrolledWindow.property.hadjustment.ext_depend = true;
Gtk324.GtkScrolledWindow.property.vadjustment.ext_depend = true;
--Gtk324.GtkViewport.property.hadjustment.ext_depend = true;
--Gtk324.GtkViewport.property.vadjustment.ext_depend = true;
Gtk324.GtkFileChooserButton.property.dialog.ext_depend = true;
Gtk324.GtkScaleButton.property.adjustment.ext_depend = true;
Gtk324.GtkEntry.property.buffer.ext_depend = true;
Gtk324.GtkFileChooser.property.filter.ext_depend = true;

------------------------  属性补丁，如下属性，生成的代码中，需要在所有函数声明前增加一个统一的补丁函数
Gtk324.GtkActivatable.property["related-action"].macro_code = {uisources = "TOP_WIDGET"};
Gtk324.GtkEntryCompletion.property.model.macro_code = {uisources = "TOP_WIDGET"};
Gtk324.GtkPrintOperation.property["default-page-setup"].macro_code = {uisources = "TOP_WIDGET"};
Gtk324.GtkPrintOperation.property["print-settings"].macro_code = {uisources = "TOP_WIDGET"};
Gtk324.GtkTextBuffer.property["tag-table"].macro_code = {uisources = "TOP_WIDGET"};
Gtk324.GtkTreeModelSort.property.model.macro_code = {uisources = "TOP_WIDGET"};
Gtk324.GtkRadioAction.property.group.macro_code = {uisources = "TOP_WIDGET"};
Gtk324.GtkCellRendererCombo.property.model.macro_code = {uisources = "TOP_WIDGET"};
Gtk324.GtkCellRendererSpin.property.adjustment.macro_code = {uisources = "TOP_WIDGET"};
Gtk324.GtkIconView.property.model.macro_code = {uisources = "TOP_WIDGET"};
--Gtk324.GtkLayout.property.hadjustment.macro_code = {uisources = "TOP_WIDGET"};
--Gtk324.GtkLayout.property.vadjustment.macro_code = {uisources = "TOP_WIDGET"};
--Gtk324.GtkProgressBar.property.adjustment.macro_code = {uisources = "TOP_WIDGET"};
Gtk324.GtkSpinButton.property.adjustment.macro_code = {uisources = "TOP_WIDGET"};
Gtk324.GtkTextView.property.buffer.macro_code = {uisources = "TOP_WIDGET"};
Gtk324.GtkTreeView.property["expander-column"].macro_code = {uisources = "TOP_WIDGET"};
--Gtk324.GtkTreeView.property.hadjustment.macro_code = {uisources = "TOP_WIDGET"};
Gtk324.GtkTreeView.property.model.macro_code = {uisources = "TOP_WIDGET"};
--Gtk324.GtkTreeView.property.vadjustment.macro_code = {uisources = "TOP_WIDGET"};
Gtk324.GtkComboBox.property.model.macro_code = {uisources = "TOP_WIDGET"};
Gtk324.GtkScrolledWindow.property.hadjustment.macro_code = {uisources = "TOP_WIDGET"};
Gtk324.GtkScrolledWindow.property.vadjustment.macro_code = {uisources = "TOP_WIDGET"};
--Gtk324.GtkViewport.property.hadjustment.macro_code = {uisources = "TOP_WIDGET"};
--Gtk324.GtkViewport.property.vadjustment.macro_code = {uisources = "TOP_WIDGET"};
Gtk324.GtkFileChooserButton.property.dialog.macro_code = {uisources = "TOP_WIDGET"};
Gtk324.GtkScaleButton.property.adjustment.macro_code = {uisources = "TOP_WIDGET"};
Gtk324.GtkFileChooser.property.filter.macro_code = {uisources = "TOP_WIDGET"};

Gtk324.GtkTextTag.property["background-gdk"].macro_code = {uisources = "GDK_COLOR"};
Gtk324.GtkTextTag.property["foreground-gdk"].macro_code = {uisources = "GDK_COLOR"};
Gtk324.GtkTextTag.property["paragraph-background-gdk"].macro_code = {uisources = "GDK_COLOR"};
Gtk324.GtkCellRenderer.property["cell-background-gdk"].macro_code = {uisources = "GDK_COLOR"};
Gtk324.GtkCellRendererText.property["background-gdk"].macro_code = {uisources = "GDK_COLOR"};
Gtk324.GtkCellRendererText.property["foreground-gdk"].macro_code = {uisources = "GDK_COLOR"};
-- 这个允许为NULL
Gtk324.GtkCellView.property.background.macro_code = {uisources = "GDK_COLOR2"};
Gtk324.GtkCellView.property["background-gdk"].macro_code = {uisources = "GDK_COLOR"};
Gtk324.GtkColorButton.property.color.macro_code = {uisources = "GDK_COLOR"};
Gtk324.GtkColorButton.property.color.macro_code = {uisources = "GDK_COLOR"};
Gtk324.GtkColorSelection.property["current-color"].macro_code = {uisources = "GDK_COLOR"};

Gtk324.GtkEntry.property.buffer.macro_code = {uisources = "TOP_WIDGET"};

Gtk324.GtkStatusIcon.property.pixbuf.macro_code = {uisources = "GTK_LOAD_GDK_PIX_BUF"};
Gtk324.GtkCellRendererPixbuf.property.pixbuf.macro_code = {uisources = "GTK_LOAD_GDK_PIX_BUF"};
Gtk324.GtkCellRendererPixbuf.property["pixbuf-expander-closed"].macro_code = {uisources = "GTK_LOAD_GDK_PIX_BUF"};
Gtk324.GtkCellRendererPixbuf.property["pixbuf-expander-open"].macro_code = {uisources = "GTK_LOAD_GDK_PIX_BUF"};
Gtk324.GtkEntry.property["primary-icon-pixbuf"]["macro_code"] = {uisources = "GTK_LOAD_GDK_PIX_BUF"};
Gtk324.GtkEntry.property["secondary-icon-pixbuf"]["macro_code"] = {uisources = "GTK_LOAD_GDK_PIX_BUF"};
Gtk324.GtkImage.property.pixbuf.macro_code = {uisources = "GTK_LOAD_GDK_PIX_BUF"};
Gtk324.GtkWindow.property.icon.macro_code = {uisources = "GTK_LOAD_GDK_PIX_BUF"};
Gtk324.GtkAssistant.child_property["header-image"].macro_code = {uisources = "GTK_LOAD_GDK_PIX_BUF"};
Gtk324.GtkAssistant.child_property["sidebar-image"].macro_code = {uisources = "GTK_LOAD_GDK_PIX_BUF"};
Gtk324.GtkAboutDialog.property.logo.macro_code = {uisources = "GTK_LOAD_GDK_PIX_BUF"};

Gtk324.GtkColorChooser.property["rgba"].macro_code = {uisources = "GDK_RGBA"};
Gtk324.GtkCellRenderer.property["cell-background-rgba"].macro_code = {uisources = "GDK_RGBA"};
Gtk324.GtkTextTag.property["background-rgba"].macro_code = {uisources = "GDK_RGBA"};
Gtk324.GtkTextTag.property["foreground-rgba"].macro_code = {uisources = "GDK_RGBA"};
Gtk324.GtkTextTag.property["paragraph-background-rgba"].macro_code = {uisources = "GDK_RGBA"};
Gtk324.GtkTextTag.property["strikethrough-rgba"].macro_code = {uisources = "GDK_RGBA"};
Gtk324.GtkTextTag.property["underline-rgba"].macro_code = {uisources = "GDK_RGBA"};
Gtk324.GtkCellRendererText.property["background-rgba"].macro_code = {uisources = "GDK_RGBA"};
Gtk324.GtkCellRendererText.property["foreground-rgba"].macro_code = {uisources = "GDK_RGBA"};
Gtk324.GtkCellView.property["background-rgba"].macro_code = {uisources = "GDK_RGBA"};
Gtk324.GtkColorSelection.property["current-rgba"].macro_code = {uisources = "GDK_RGBA"};
Gtk324.GtkColorButton.property["rgba"].macro_code = {uisources = "GDK_RGBA"};

---- 末尾处，表的拷贝函数不再需要了
Gtk324.PatchGlibProperty = nil;
Gtk324.insert_more = nil;
Gtk324.copy_and_insert_more = nil;
Gtk324.table_copy_table_in_patch = nil;
